git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/tools.c

   1 /* tools.c - tools for slap tools */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11 #include <ac/string.h>
  12
  13 #include "back-bdb.h"
  14
  15 static DBC *cursor = NULL;
  16 static DBT key, data;
  17
  18 typedef struct dn_id {
  19         ID id;
  20         struct berval dn;
  21 } dn_id;
  22
  23 #define HOLE_SIZE       4096
  24 dn_id hbuf[HOLE_SIZE], *holes = hbuf;
  25 unsigned nhmax = HOLE_SIZE;
  26 unsigned nholes;
  27
  28 int bdb_tool_entry_open(
  29         BackendDB *be, int mode )
  30 {
  31         /* initialize key and data thangs */
  32         DBTzero( &key );
  33         DBTzero( &data );
  34         key.flags = DB_DBT_REALLOC;
  35         data.flags = DB_DBT_REALLOC;
  36
  37         return 0;
  38 }
  39
  40 int bdb_tool_entry_close(
  41         BackendDB *be )
  42 {
  43         assert( be != NULL );
  44
  45         if( key.data ) {
  46                 ch_free( key.data );
  47                 key.data = NULL;
  48         }
  49         if( data.data ) {
  50                 ch_free( data.data );
  51                 data.data = NULL;
  52         }
  53
  54         if( cursor ) {
  55                 cursor->c_close( cursor );
  56                 cursor = NULL;
  57         }
  58
  59         if( nholes ) {
  60                 unsigned i;
  61                 fprintf( stderr, "Error, entries missing!\n");
  62                 for (i=0; i<nholes; i++) {
  63                         fprintf(stderr, "  entry %d: %s\n",
  64                                 holes[i].id, holes[i].dn.bv_val, 0);
  65                 }
  66                 return -1;
  67         }
  68
  69         return 0;
  70 }
  71
  72 ID bdb_tool_entry_next(
  73         BackendDB *be )
  74 {
  75         int rc;
  76         ID id;
  77         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
  78
  79         assert( be != NULL );
  80         assert( slapMode & SLAP_TOOL_MODE );
  81         assert( bdb != NULL );
  82
  83         if (cursor == NULL) {
  84                 rc = bdb->bi_id2entry->bdi_db->cursor(
  85                         bdb->bi_id2entry->bdi_db, NULL, &cursor,
  86                         bdb->bi_db_opflags );
  87                 if( rc != 0 ) {
  88                         return NOID;
  89                 }
  90         }
  91
  92         rc = cursor->c_get( cursor, &key, &data, DB_NEXT );
  93
  94         if( rc != 0 ) {
  95                 return NOID;
  96         }
  97
  98         if( data.data == NULL ) {
  99                 return NOID;
 100         }
 101
 102         AC_MEMCPY( &id, key.data, key.size );
 103         return id;
 104 }
 105
 106 Entry* bdb_tool_entry_get( BackendDB *be, ID id )
 107 {
 108         int rc;
 109         Entry *e;
 110         struct berval bv;
 111
 112         assert( be != NULL );
 113         assert( slapMode & SLAP_TOOL_MODE );
 114         assert( data.data != NULL );
 115
 116         DBT2bv( &data, &bv );
 117
 118         rc = entry_decode( &bv, &e );
 119
 120         if( rc == LDAP_SUCCESS ) {
 121                 e->e_id = id;
 122         }
 123
 124 #ifdef BDB_HIER
 125         bdb_fix_dn(be, id, e);
 126 #endif
 127
 128         return e;
 129 }
 130
 131 int bdb_tool_next_id(
 132         BackendDB *be,
 133         DB_TXN *tid,
 134         Entry *e,
 135         struct berval *text,
 136         int hole )
 137 {
 138         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
 139         struct berval dn = e->e_nname;
 140         struct berval pdn;
 141         int rc;
 142
 143         rc = bdb_dn2id( be, tid, &dn, &e->e_id, 0 );
 144         if ( rc == DB_NOTFOUND ) {
 145                 if ( be_issuffix( be, &dn ) ) {
 146                         pdn = slap_empty_bv;
 147                 } else {
 148                         dnParent( &dn, &pdn );
 149                         e->e_nname = pdn;
 150                         rc = bdb_tool_next_id( be, tid, e, text, 1 );
 151                         if ( rc ) {
 152                                 return rc;
 153                         }
 154                 }
 155                 rc = bdb_next_id( be, tid, &e->e_id );
 156                 if ( rc ) {
 157                         snprintf( text->bv_val, text->bv_len,
 158                                 "next_id failed: %s (%d)",
 159                                 db_strerror(rc), rc );
 160 #ifdef NEW_LOGGING
 161                 LDAP_LOG ( TOOLS, ERR,
 162                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 163 #else
 164                 Debug( LDAP_DEBUG_ANY,
 165                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 166 #endif
 167                         return rc;
 168                 }
 169                 e->e_nname = dn;
 170                 rc = bdb_dn2id_add( be, tid, &pdn, e );
 171                 if ( rc ) {
 172                         snprintf( text->bv_val, text->bv_len,
 173                                 "dn2id_add failed: %s (%d)",
 174                                 db_strerror(rc), rc );
 175 #ifdef NEW_LOGGING
 176                 LDAP_LOG ( TOOLS, ERR,
 177                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 178 #else
 179                 Debug( LDAP_DEBUG_ANY,
 180                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 181 #endif
 182                 } else if ( hole ) {
 183                         if ( nholes == nhmax - 1 ) {
 184                                 if ( holes == hbuf ) {
 185                                         holes = ch_malloc( nhmax * sizeof(ID) * 2 );
 186                                         AC_MEMCPY( holes, hbuf, sizeof(hbuf) );
 187                                 } else {
 188                                         holes = ch_realloc( holes, nhmax * sizeof(ID) * 2 );
 189                                 }
 190                                 nhmax *= 2;
 191                         }
 192                         ber_dupbv( &holes[nholes].dn, &dn );
 193                         holes[nholes++].id = e->e_id;
 194                 }
 195         } else if ( !hole ) {
 196                 unsigned i;
 197
 198                 for ( i=0; i<nholes; i++) {
 199                         if ( holes[i].id == e->e_id ) {
 200                                 int j;
 201                                 free(holes[i].dn.bv_val);
 202                                 for (j=i;j<nholes;j++) holes[j] = holes[j+1];
 203                                 holes[j].id = 0;
 204                                 nholes--;
 205                                 break;
 206                         } else if ( holes[i].id > e->e_id ) {
 207                                 break;
 208                         }
 209                 }
 210         }
 211         return rc;
 212 }
 213
 214 ID bdb_tool_entry_put(
 215         BackendDB *be,
 216         Entry *e,
 217         struct berval *text )
 218 {
 219         int rc;
 220         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
 221         DB_TXN *tid = NULL;
 222         struct berval pdn;
 223
 224         assert( be != NULL );
 225         assert( slapMode & SLAP_TOOL_MODE );
 226
 227         assert( text );
 228         assert( text->bv_val );
 229         assert( text->bv_val[0] == '\0' );      /* overconservative? */
 230
 231 #ifdef NEW_LOGGING
 232         LDAP_LOG ( TOOLS, ARGS, "=> bdb_tool_entry_put( %ld, \"%s\" )\n",
 233                 (long) e->e_id, e->e_dn, 0 );
 234 #else
 235         Debug( LDAP_DEBUG_TRACE, "=> bdb_tool_entry_put( %ld, \"%s\" )\n",
 236                 (long) e->e_id, e->e_dn, 0 );
 237 #endif
 238
 239         rc = TXN_BEGIN( bdb->bi_dbenv, NULL, &tid,
 240                 bdb->bi_db_opflags );
 241         if( rc != 0 ) {
 242                 snprintf( text->bv_val, text->bv_len,
 243                         "txn_begin failed: %s (%d)",
 244                         db_strerror(rc), rc );
 245 #ifdef NEW_LOGGING
 246         LDAP_LOG ( TOOLS, ERR, "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 247 #else
 248                 Debug( LDAP_DEBUG_ANY,
 249                         "=> bdb_tool_entry_put: %s\n",
 250                          text->bv_val, 0, 0 );
 251 #endif
 252                 return NOID;
 253         }
 254
 255         /* add dn2id indices */
 256         rc = bdb_tool_next_id( be, tid, e, text, 0 );
 257         if( rc != 0 ) {
 258                 goto done;
 259         }
 260
 261         /* id2entry index */
 262         rc = bdb_id2entry_add( be, tid, e );
 263         if( rc != 0 ) {
 264                 snprintf( text->bv_val, text->bv_len,
 265                                 "id2entry_add failed: %s (%d)",
 266                                 db_strerror(rc), rc );
 267 #ifdef NEW_LOGGING
 268                 LDAP_LOG ( TOOLS, ERR,
 269                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 270 #else
 271                 Debug( LDAP_DEBUG_ANY,
 272                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 273 #endif
 274                 goto done;
 275         }
 276
 277         rc = bdb_index_entry_add( be, tid, e );
 278         if( rc != 0 ) {
 279                 snprintf( text->bv_val, text->bv_len,
 280                                 "index_entry_add failed: %s (%d)",
 281                                 db_strerror(rc), rc );
 282 #ifdef NEW_LOGGING
 283                 LDAP_LOG ( TOOLS, ERR,
 284                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 285 #else
 286                 Debug( LDAP_DEBUG_ANY,
 287                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 288 #endif
 289                 goto done;
 290         }
 291
 292 done:
 293         if( rc == 0 ) {
 294                 rc = TXN_COMMIT( tid, 0 );
 295                 if( rc != 0 ) {
 296                         snprintf( text->bv_val, text->bv_len,
 297                                         "txn_commit failed: %s (%d)",
 298                                         db_strerror(rc), rc );
 299 #ifdef NEW_LOGGING
 300                         LDAP_LOG ( TOOLS, ERR,
 301                                 "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 302 #else
 303                         Debug( LDAP_DEBUG_ANY,
 304                                 "=> bdb_tool_entry_put: %s\n",
 305                                 text->bv_val, 0, 0 );
 306 #endif
 307                         e->e_id = NOID;
 308                 }
 309
 310         } else {
 311                 TXN_ABORT( tid );
 312                 snprintf( text->bv_val, text->bv_len,
 313                         "txn_aborted! %s (%d)",
 314                         db_strerror(rc), rc );
 315 #ifdef NEW_LOGGING
 316                 LDAP_LOG ( TOOLS, ERR,
 317                         "=> bdb_tool_entry_put: %s\n", text->bv_val, 0, 0 );
 318 #else
 319                 Debug( LDAP_DEBUG_ANY,
 320                         "=> bdb_tool_entry_put: %s\n",
 321                         text->bv_val, 0, 0 );
 322 #endif
 323                 e->e_id = NOID;
 324         }
 325
 326         return e->e_id;
 327 }
 328
 329 int bdb_tool_entry_reindex(
 330         BackendDB *be,
 331         ID id )
 332 {
 333         struct bdb_info *bi = (struct bdb_info *) be->be_private;
 334         int rc;
 335         Entry *e;
 336         DB_TXN *tid = NULL;
 337         struct berval pdn;
 338
 339 #ifdef NEW_LOGGING
 340         LDAP_LOG ( TOOLS, ARGS,
 341                 "=> bdb_tool_entry_reindex( %ld )\n", (long) id, 0, 0 );
 342 #else
 343         Debug( LDAP_DEBUG_ARGS, "=> bdb_tool_entry_reindex( %ld )\n",
 344                 (long) id, 0, 0 );
 345 #endif
 346
 347         e = bdb_tool_entry_get( be, id );
 348
 349         if( e == NULL ) {
 350 #ifdef NEW_LOGGING
 351                 LDAP_LOG ( TOOLS, DETAIL1,
 352                         "bdb_tool_entry_reindex:: could not locate id=%ld\n",
 353                         (long) id, 0, 0 );
 354 #else
 355                 Debug( LDAP_DEBUG_ANY,
 356                         "bdb_tool_entry_reindex:: could not locate id=%ld\n",
 357                         (long) id, 0, 0 );
 358 #endif
 359                 return -1;
 360         }
 361
 362         rc = TXN_BEGIN( bi->bi_dbenv, NULL, &tid, bi->bi_db_opflags );
 363         if( rc != 0 ) {
 364 #ifdef NEW_LOGGING
 365                 LDAP_LOG ( TOOLS, ERR,
 366                         "=> bdb_tool_entry_reindex: txn_begin failed: %s (%d)\n",
 367                         db_strerror(rc), rc, 0 );
 368 #else
 369                 Debug( LDAP_DEBUG_ANY,
 370                         "=> bdb_tool_entry_reindex: txn_begin failed: %s (%d)\n",
 371                         db_strerror(rc), rc, 0 );
 372 #endif
 373                 goto done;
 374         }
 375
 376         /*
 377          * just (re)add them for now
 378          * assume that some other routine (not yet implemented)
 379          * will zap index databases
 380          *
 381          */
 382
 383 #ifdef NEW_LOGGING
 384         LDAP_LOG ( TOOLS, ERR,
 385                 "=> bdb_tool_entry_reindex( %ld, \"%s\" )\n", (long) id, e->e_dn, 0 );
 386 #else
 387         Debug( LDAP_DEBUG_TRACE, "=> bdb_tool_entry_reindex( %ld, \"%s\" )\n",
 388                 (long) id, e->e_dn, 0 );
 389 #endif
 390
 391         /* add dn2id indices */
 392         if ( be_issuffix( be, &e->e_nname ) ) {
 393                 pdn = slap_empty_bv;
 394         } else {
 395                 dnParent( &e->e_nname, &pdn );
 396         }
 397         rc = bdb_dn2id_add( be, tid, &pdn, e );
 398         if( rc != 0 && rc != DB_KEYEXIST ) {
 399 #ifdef NEW_LOGGING
 400                 LDAP_LOG ( TOOLS, ERR,
 401                         "=> bdb_tool_entry_reindex: dn2id_add failed: %s (%d)\n",
 402                         db_strerror(rc), rc, 0 );
 403 #else
 404                 Debug( LDAP_DEBUG_ANY,
 405                         "=> bdb_tool_entry_reindex: dn2id_add failed: %s (%d)\n",
 406                         db_strerror(rc), rc, 0 );
 407 #endif
 408                 goto done;
 409         }
 410
 411         rc = bdb_index_entry_add( be, tid, e );
 412
 413 done:
 414         if( rc == 0 ) {
 415                 rc = TXN_COMMIT( tid, 0 );
 416                 if( rc != 0 ) {
 417 #ifdef NEW_LOGGING
 418                         LDAP_LOG ( TOOLS, ERR,
 419                                 "=> bdb_tool_entry_reindex: txn_commit failed: %s (%d)\n",
 420                                 db_strerror(rc), rc, 0 );
 421 #else
 422                         Debug( LDAP_DEBUG_ANY,
 423                                 "=> bdb_tool_entry_reindex: txn_commit failed: %s (%d)\n",
 424                                 db_strerror(rc), rc, 0 );
 425 #endif
 426                         e->e_id = NOID;
 427                 }
 428
 429         } else {
 430                 TXN_ABORT( tid );
 431 #ifdef NEW_LOGGING
 432                 LDAP_LOG ( TOOLS, DETAIL1,
 433                         "=> bdb_tool_entry_reindex: txn_aborted! %s (%d)\n",
 434                         db_strerror(rc), rc, 0 );
 435 #else
 436                 Debug( LDAP_DEBUG_ANY,
 437                         "=> bdb_tool_entry_reindex: txn_aborted! %s (%d)\n",
 438                         db_strerror(rc), rc, 0 );
 439 #endif
 440                 e->e_id = NOID;
 441         }
 442
 443         return rc;
 444 }