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

   1 #include "portable.h"
   2
   3 #include <stdio.h>
   4 #include <limits.h>
   5
   6 #include <ac/stdlib.h>
   7 #include <ac/socket.h>
   8 #include <ac/string.h>
   9 #include <ac/ctype.h>
  10 #include <ac/time.h>
  11 #include <ac/unistd.h>
  12 #include <ac/wait.h>
  13
  14 #ifdef HAVE_SYS_RESOURCE_H
  15 #include <sys/resource.h>
  16 #endif
  17 #ifdef HAVE_SYS_PARAM_H
  18 #include <sys/param.h>
  19 #endif
  20 #include <sys/stat.h>
  21
  22 #ifdef HAVE_FCNTL_H
  23 #include <fcntl.h>
  24 #endif
  25
  26 #ifdef HAVE_IO_H
  27 #include <io.h>
  28 #endif
  29
  30 #include "ldap_defaults.h"
  31 #include "../slap.h"
  32 #include "../back-ldbm/back-ldbm.h"
  33
  34 static DBCache  *openchoice(char c, int mode, int verbose, char **fname);
  35 static void             print_entry(FILE *fp, char c, Datum *key, char *klabel, Datum *data, char *dlabel);
  36 static void             free_and_close(DBCache *dbc, Datum key, Datum data);
  37 static void             edit_entry(char c, Datum *data);
  38 static void             get_keydata(FILE *fp, char c, Datum *key, Datum *data);
  39
  40 static DBCache *dbc;
  41 static LDBM           dbp;
  42 static Backend          *be = NULL;
  43
  44 int
  45 main( int argc, char **argv )
  46 {
  47         char            buf[256];
  48         Datum           savekey, key, data, last;
  49         char            *fname;
  50         ID              id;
  51         ID_BLOCK                *idl;
  52         Backend         *tbe;
  53         int             i;
  54         char            *tailorfile;
  55
  56 #ifdef HAVE_BERKELEY_DB2
  57         DBC     *cursorp;
  58 #endif
  59
  60         ldbm_datum_init( savekey );
  61         ldbm_datum_init( key );
  62         ldbm_datum_init( data );
  63         ldbm_datum_init( last );
  64
  65         tailorfile = SLAPD_DEFAULT_CONFIGFILE;
  66         while ( (i = getopt( argc, argv, "d:f:" )) != EOF ) {
  67                 switch ( i ) {
  68                 case 'd':       /* turn on debugging */
  69                         ldap_debug = atoi( optarg );
  70                         break;
  71
  72                 case 'f':       /* specify a tailor file */
  73                         tailorfile = strdup( optarg );
  74                         break;
  75
  76                 default:
  77                         fprintf( stderr,
  78                             "usage: %s [-d level] [-f slapdconfigfile]\n",
  79                             argv[0] );
  80                         exit( EXIT_FAILURE );
  81                 }
  82         }
  83
  84         /*
  85          * initialize stuff and figure out which backend we're dealing with
  86          */
  87
  88         slap_init(SLAP_TOOL_MODE, "ldbmtest");
  89         read_config( tailorfile );
  90         slap_startup(-1);
  91
  92         while ( 1 ) {
  93                 printf( "dbtest: " );
  94
  95                 if ( fgets( buf, sizeof(buf), stdin ) == NULL )
  96                         break;
  97
  98                 switch ( buf[0] ) {
  99                 case 'c':       /* create an index */
 100                         fname = NULL;
 101                         if ( (dbc = openchoice( buf[1], LDBM_READER, 0,
 102                             &fname )) != NULL ) {
 103                                 printf( "Already exists\n" );
 104                                 ldbm_close( dbc->dbc_db );
 105                                 break;
 106                         }
 107                         if ( (dbc = openchoice( buf[1], LDBM_WRCREAT, 1,
 108                             &fname )) != NULL ) {
 109                                 ldbm_close( dbc->dbc_db );
 110                         }
 111                         break;
 112
 113                 case 'l':       /* lookup somethig in an index */
 114                         if ( (dbc = openchoice( buf[1], LDBM_READER, 1, NULL ))
 115                             == NULL ) {
 116                                 continue;
 117                         }
 118
 119                         get_keydata( stdin, buf[1], &key, NULL );
 120                         data = ldbm_fetch( dbc->dbc_db, key );
 121                         print_entry( stdout, buf[1], &key, "key: ", &data,
 122                             "data:\n" );
 123
 124                         free_and_close( dbc, key, data );
 125                         break;
 126
 127                 case 'L':       /* get all blocks for a key from an index */
 128                         if ( (dbc = openchoice( buf[1], LDBM_READER, 1, NULL ))
 129                             == NULL ) {
 130                                 continue;
 131                         }
 132
 133                         get_keydata( stdin, buf[1], &key, NULL );
 134                         if ( (idl = idl_fetch( be, dbc, key )) != NULL ) {
 135                                 data.dptr = (char *) idl;
 136                                 data.dsize = (ID_BLOCK_NMAX(idl) + 1) * sizeof(ID);
 137                                 print_entry( stdout, buf[1], &key, "key: ",
 138                                     &data, "data:\n" );
 139                         }
 140                         free_and_close( dbc, key, data );
 141                         break;
 142
 143                 case 't':       /* traverse */
 144                 case 'T':       /* traverse - keys only */
 145                         if ( (dbc = openchoice( buf[1], LDBM_READER, 1, NULL ))
 146                             == NULL ) {
 147                                 perror( "openchoice" );
 148                                 continue;
 149                         }
 150
 151                         savekey.dptr = NULL;
 152 #ifdef HAVE_BERKELEY_DB2
 153                         for ( key = ldbm_firstkey( dbc->dbc_db, &cursorp );
 154                             key.dptr != NULL;
 155                             key = ldbm_nextkey( dbc->dbc_db, key, cursorp ) )
 156 #else
 157                         for ( key = ldbm_firstkey( dbc->dbc_db );
 158                             key.dptr != NULL;
 159                             key = ldbm_nextkey( dbc->dbc_db, key ) )
 160 #endif
 161                         {
 162                                 if ( savekey.dptr != NULL )
 163                                         ldbm_datum_free( dbc->dbc_db, savekey );
 164                                 savekey = key;
 165
 166                                 data = ldbm_fetch( dbc->dbc_db, key );
 167
 168                                 if ( buf[0] == 't' ) {
 169                                         print_entry( stdout, buf[1], &key,
 170                                             "key: ", &data, "data:\n" );
 171                                 } else {
 172                                         print_entry( stdout, buf[1], &key,
 173                                             "key: ", NULL, NULL );
 174                                 }
 175
 176                 if ( data.dptr != NULL ) {
 177                                     ldbm_datum_free( dbc->dbc_db, data );
 178                 }
 179                         }
 180                         if ( savekey.dptr != NULL )
 181                                 ldbm_datum_free( dbc->dbc_db, savekey );
 182
 183                         ldbm_close( dbc->dbc_db );
 184                         break;
 185
 186                 case 'x':       /* delete an entry */
 187                         if ( (dbc = openchoice( buf[1], LDBM_WRITER, 1, NULL ))
 188                             == NULL ) {
 189                                 continue;
 190                         }
 191
 192                         get_keydata( stdin, buf[1], &key, NULL );
 193
 194                         if ( ldbm_delete( dbc->dbc_db, key ) != 0 ) {
 195                                 if ( ldbm_errno( dbc->dbc_db ) == 0 ) {
 196                                         perror( "ldbm_delete" );
 197                                 } else {
 198                                         fprintf( stderr, "db_errno %d",
 199                                             ldbm_errno( dbc->dbc_db ) );
 200                                 }
 201                         }
 202
 203                         data.dptr = NULL;
 204                         free_and_close( dbc, key, data );
 205                         break;
 206
 207 #ifndef HAVE_WINSOCK
 208                 case 'e':       /* edit an entry */
 209                         if ( (dbc = openchoice( buf[1], LDBM_WRITER, 1, NULL ))
 210                             == NULL ) {
 211                                 continue;
 212                         }
 213
 214                         get_keydata( stdin, buf[1], &key, NULL );
 215
 216                         data = ldbm_fetch( dbc->dbc_db, key );
 217                         if ( data.dptr == NULL ) {
 218                                 if ( ldbm_errno( dbc->dbc_db ) == 0 ) {
 219                                         perror( "ldbm_fetch" );
 220                                 } else {
 221                                         fprintf( stderr, "db_errno %d\n",
 222                                             ldbm_errno( dbc->dbc_db ) );
 223                                 }
 224                                 free_and_close( dbc, key, data );
 225                                 break;
 226                         }
 227
 228                         edit_entry( buf[1], &data );
 229
 230                         if ( data.dptr == NULL ) {
 231                                 if ( ldbm_delete( dbc->dbc_db, key ) != 0 ) {
 232                                         perror( "ldbm_delete" );
 233                                 }
 234                         } else if ( ldbm_store( dbc->dbc_db, key, data,
 235                             LDBM_REPLACE ) != 0 ) {
 236                                 if ( ldbm_errno( dbc->dbc_db ) == 0 ) {
 237                                         perror( "ldbm_store" );
 238                                 } else {
 239                                         fprintf( stderr, "db_errno %d\n",
 240                                             ldbm_errno( dbc->dbc_db ) );
 241                                 }
 242                         }
 243
 244                         free_and_close( dbc, key, data );
 245                         break;
 246 #endif
 247
 248                 case 'a':       /* add an entry */
 249                         if ( (dbc = openchoice( buf[1], LDBM_WRITER, 1, NULL ))
 250                             == NULL ) {
 251                                 continue;
 252                         }
 253
 254                         get_keydata( stdin, buf[1], &key, &data );
 255
 256                         if ( ldbm_store( dbc->dbc_db, key, data, LDBM_INSERT )
 257                             != 0 ) {
 258                                 if ( ldbm_errno( dbc->dbc_db ) == 0 ) {
 259                                         perror( "ldbm_store" );
 260                                 } else {
 261                                         fprintf( stderr, "db_errno %d\n",
 262                                             ldbm_errno( dbc->dbc_db ) );
 263                                 }
 264                         }
 265
 266                         free_and_close( dbc, key, data );
 267                         break;
 268
 269                 case 'i':       /* insert an id into an index entry */
 270                         if ( (dbc = openchoice( buf[1], LDBM_WRITER, 1, NULL ))
 271                             == NULL ) {
 272                                 continue;
 273                         }
 274
 275                         get_keydata( stdin, buf[1], &key, &data );
 276
 277                         idl = (ID_BLOCK *) data.dptr;
 278                         for ( id = idl_firstid( idl ); id != NOID;
 279                             id = idl_nextid( idl, id ) ) {
 280                                 if ( idl_insert_key( be, dbc, key, id )
 281                                     != 0 ) {
 282                                         fprintf( stderr,
 283                                             "idl_insert_key (%s) %ld failed\n",
 284                                             key.dptr, id );
 285                                         continue;
 286                                 }
 287                         }
 288
 289                         free_and_close( dbc, key, data );
 290                         break;
 291
 292                 case 'b':       /* select a backend by suffix */
 293                         printf( "suffix: " );
 294                         fflush( stdout );
 295                         if ( fgets( buf, sizeof(buf), stdin ) == NULL ) {
 296                                 exit( EXIT_SUCCESS );
 297                         } else {
 298                                 buf[strlen( buf ) - 1] = '\0';
 299                         }
 300                         (void) dn_normalize_case( buf );
 301                         if ( (tbe = select_backend( buf )) == NULL ) {
 302                                 fprintf( stderr, "unknown suffix \"%s\"\n",
 303                                     buf );
 304                         } else {
 305                                 be = tbe;
 306                         }
 307                         break;
 308
 309                 case 'B':       /* print current suffix */
 310                         if ( be == NULL ) {
 311                                 printf( "no current backend\n" );
 312                         } else {
 313                                 printf( "current backend has suffix \"%s\"\n",
 314                                     be->be_suffix[0] );
 315                         }
 316                         break;
 317
 318                 case 'C':       /* produce concordance of an index */
 319                         if ( (dbc = openchoice( 'i', LDBM_READER, 1, NULL ))
 320                             == NULL ) {
 321                                 continue;
 322                         }
 323
 324                         last.dptr = NULL;
 325
 326 #ifdef HAVE_BERKELEY_DB2
 327                         for ( key = ldbm_firstkey( dbp, &cursorp );
 328                                 key.dptr != NULL;
 329                                 key = ldbm_nextkey( dbp, last, cursorp ) )
 330 #else
 331                         for ( key = ldbm_firstkey( dbp ); key.dptr != NULL;
 332                             key = ldbm_nextkey( dbp, last ) )
 333 #endif
 334                         {
 335                                 if ( last.dptr != NULL ) {
 336                                         ldbm_datum_free( dbp, last );
 337                                 }
 338                                 last = key;
 339                                 printf( "key(%d): (%s)\n", key.dsize,
 340                                     key.dptr );
 341                         }
 342
 343                         free_and_close( dbc, key, last );
 344                         break;
 345
 346                 default:
 347                         printf( "commands: l<c> => lookup index\n" );
 348                         printf( "          L<c> => lookup index (all)\n" );
 349                         printf( "          t<c> => traverse index\n" );
 350                         printf( "          T<c> => traverse index keys\n" );
 351                         printf( "          x<c> => delete from index\n" );
 352                         printf( "          e<c> => edit index entry\n" );
 353                         printf( "          a<c> => add index entry\n" );
 354                         printf( "          c<c> => create index\n" );
 355                         printf( "          i<c> => insert ids into index\n" );
 356                         printf( "          b    => change default backend\n" );
 357                         printf( "          B    => print default backend\n" );
 358                         printf( "where <c> is a char selecting the index:\n" );
 359                         printf( "          c => id2children\n" );
 360                         printf( "          d => dn2id\n" );
 361                         printf( "          e => id2entry\n" );
 362                         printf( "          f => arbitrary file\n" );
 363                         printf( "          i => attribute index\n" );
 364                         break;
 365                 }
 366         }
 367
 368         slap_shutdown(-1);
 369         slap_destroy();
 370
 371         return( EXIT_SUCCESS );
 372 }
 373
 374 static void
 375 free_and_close( DBCache *dbc, Datum key, Datum data )
 376 {
 377         ldbm_cache_really_close( be, dbc );
 378         if ( key.dptr != NULL )
 379                 ldbm_datum_free( dbp, key );
 380         if ( data.dptr != NULL )
 381                 ldbm_datum_free( dbp, data );
 382 }
 383
 384 static int
 385 dnid_cmp( const void *a, const void *b )
 386 {
 387         return( *(const long int *)a - *(const long int *)b );
 388 }
 389
 390 static char *
 391 myrealloc( char *p, int size )
 392 {
 393         if ( p == NULL )
 394                 return( (char *) malloc( size ) );
 395         else
 396                 return( (char *) realloc( p, size ) );
 397 }
 398
 399 static void
 400 get_idlist( FILE *fp, Datum *data )
 401 {
 402         char    buf[20];
 403         int     i, fd, tty;
 404         ID_BLOCK        *p;
 405         unsigned int    psize, pmax;
 406         unsigned int    nmax, nids;
 407
 408         fd = fileno( fp );
 409         tty = isatty( fd );
 410
 411         p = NULL;
 412         psize = 2 * sizeof(ID);
 413         pmax = 0;
 414         nmax = 0;
 415         nids = 0;
 416         i = 0;
 417         while ( 1 ) {
 418                 if ( tty )
 419                         printf( "id? " );
 420                 if ( fgets( buf, sizeof(buf), fp ) == NULL || buf[0] == '\n' )
 421                         break;
 422                 if ( strncmp( buf, "nmax=", 5 ) == 0 ) {
 423                         nmax = atol( buf + 5 );
 424                         continue;
 425                 }
 426
 427                 if ( psize + sizeof(ID) > pmax ) {
 428                         pmax += BUFSIZ;
 429                         p = (ID_BLOCK *) myrealloc( (char *) p, pmax );
 430                 }
 431
 432                 if ( strncmp( buf, "nids=0", 6 ) == 0 ) {
 433                         nids = NOID;
 434                         continue;
 435                 }
 436
 437                 ID_BLOCK_ID(p,i++) = atol( buf );
 438                 psize += sizeof(ID);
 439         }
 440         if ( nmax == 0 ) {
 441                 if ( tty ) {
 442                         nmax = i;
 443                         printf( "%d IDs entered.  Max number of ids? [%d] ", i,
 444                             i );
 445                         if ( fgets( buf, sizeof(buf), fp ) != NULL &&
 446                              isdigit( (unsigned char) buf[0] ) ) {
 447                                 nmax = atol( buf );
 448                         }
 449                 } else {
 450                         nmax = i;
 451                 }
 452         }
 453         if ( i > 0 ) {
 454                 ID_BLOCK_NMAX(p) = nmax;
 455                 if ( nids != 0 ) {
 456                         ID_BLOCK_NIDS(p) = 0;
 457                         ID_BLOCK_ID(p,i) = NOID;
 458                 } else {
 459                         ID_BLOCK_NIDS(p) = i;
 460                 }
 461
 462                 qsort( (void *) &ID_BLOCK_ID(p, 0), i, sizeof(ID), dnid_cmp );
 463         }
 464
 465         data->dptr = (char *) p;
 466         data->dsize = (nmax + ID_BLOCK_IDS_OFFSET) * sizeof(ID);
 467 }
 468
 469 static void
 470 get_entry( FILE *fp, Datum *data )
 471 {
 472         char    buf[BUFSIZ];
 473         char    *p;
 474         unsigned int    pmax, psize, len;
 475         int     fd;
 476
 477         fd = fileno( fp );
 478         if ( isatty( fd ) )
 479                 printf( "Enter entry, <cr><cr> to end:\n" );
 480
 481         p = NULL;
 482         pmax = psize = 0;
 483         while ( fgets( buf, sizeof(buf), fp ) != NULL ) {
 484                 len = strlen( buf );
 485                 if ( psize + strlen( buf ) > pmax ) {
 486                         pmax += BUFSIZ;
 487                         p = myrealloc( p, pmax );
 488                 }
 489                 if ( psize == 0 )
 490                         strcpy( p, buf );
 491                 else
 492                         strcat( p, buf );
 493                 psize += len;
 494
 495                 if ( buf[0] == '\n' )
 496                         break;
 497         }
 498
 499         data->dptr = p;
 500         data->dsize = psize + 1;
 501 }
 502
 503 #ifndef HAVE_WINSOCK
 504 static void
 505 edit_entry( char c, Datum *data )
 506 {
 507         int             fd, pid;
 508         char            tmpname[20];
 509         FILE            *fp;
 510 #ifndef HAVE_WAITPID
 511         WAITSTATUSTYPE  status;
 512 #endif
 513
 514         strcpy( tmpname, "/tmp/dbtestXXXXXX" );
 515 #ifndef HAVE_MKSTEMP
 516         if ( (fd = open( mktemp( tmpname ), O_RDWR, 0600 )) == -1 ) {
 517                 perror( tmpname );
 518                 return;
 519         }
 520 #else
 521         if ( (fd = mkstemp( tmpname )) == -1 ) {
 522                 perror( tmpname );
 523                 return;
 524         }
 525 #endif
 526
 527         fp = fdopen( fd, "w" );
 528         print_entry( fp, c, NULL, NULL, data, NULL );
 529         fflush( fp );
 530
 531         pid = fork();
 532
 533         if ( pid == -1 ) {
 534                 perror( "fork" );
 535                 return;
 536         } else if ( pid == 0 ) {
 537                 char    *editor;
 538
 539                 if ( (editor = getenv( "EDITOR" )) == NULL ) {
 540                         editor = LDAP_EDITOR;
 541                 }
 542                 execl( editor, editor, tmpname, NULL );
 543                 perror( "execl" );
 544                 exit( EXIT_FAILURE );
 545         }
 546
 547         fclose( fp );
 548
 549 #ifdef HAVE_WAITPID
 550         if ( waitpid( (pid_t) -1, NULL, WAIT_FLAGS ) < 0 )
 551 #else
 552         if ( wait3( (pid_t) -1, &status, WAIT_FLAGS, 0 ) < 0 )
 553 #endif
 554         {
 555                 perror( "wait" );
 556                 return;
 557         }
 558
 559         if ( (fp = fopen( tmpname, "r" )) == NULL ) {
 560                 perror( tmpname );
 561                 return;
 562         }
 563     if ( data->dptr != NULL ) {
 564             ldbm_datum_free( NULL, *data );
 565     }
 566         get_keydata( fp, c, NULL, data );
 567         fclose( fp );
 568         unlink( tmpname );
 569 }
 570 #endif
 571
 572 static DBCache *
 573 openfile( char *name, int namesiz, int mode, int verbose, char c )
 574 {
 575         DBCache *dbc;
 576
 577         if ( name == NULL || *name == '\0' ) {
 578                 if ( c == 'f' ) {
 579                         printf( "  file: " );
 580                         if ( fgets( name, namesiz, stdin ) == NULL )
 581                                 exit( EXIT_SUCCESS );
 582                         name[strlen( name ) - 1] = '\0';
 583                 } else {
 584                         printf( "  attr: " );
 585                         if ( fgets( name, namesiz, stdin ) == NULL )
 586                                 exit( EXIT_SUCCESS );
 587                         name[strlen( name ) - 1] = '\0';
 588                 }
 589         }
 590
 591         if ( (dbc = ldbm_cache_open( be, name, (c == 'f') ? "" : LDBM_SUFFIX,
 592             LDBM_READER )) == NULL ) {
 593                 perror( name );
 594         } else {
 595                 dbp = dbc->dbc_db;
 596         }
 597
 598         return( dbc );
 599 }
 600
 601 static DBCache *
 602 openchoice( char c, int mode, int verbose, char **fname )
 603 {
 604         static char     name[MAXPATHLEN];
 605
 606         switch ( c ) {
 607         case 'c':       /* id2children */
 608                 sprintf( name, "id2children" );
 609                 break;
 610         case 'd':       /* dn2id */
 611                 sprintf( name, "dn2id" );
 612                 break;
 613         case 'e':       /* id2entry */
 614                 sprintf( name, "id2entry" );
 615                 break;
 616         case 'f':       /* arbitrary file */
 617         case 'i':       /* index */
 618                 if ( fname != NULL && *fname != NULL ) {
 619                         strcpy( name, *fname );
 620                 } else {
 621                         name[0] = '\0';
 622                 }
 623                 break;
 624         default:
 625                 printf( "specify one of [fdeci] to select file\n" );
 626                 return( NULL );
 627                 break;
 628         }
 629         if ( fname != NULL ) {
 630                 *fname = name;
 631         }
 632
 633         return( openfile( name, MAXPATHLEN, mode, verbose, c ) );
 634 }
 635
 636 static void
 637 print_entry(
 638         FILE    *fp,
 639         char    c,
 640         Datum   *key,
 641         char    *klabel,
 642         Datum   *data,
 643         char    *dlabel
 644 )
 645 {
 646         ID      id;
 647         ID_BLOCK        *idl;
 648         unsigned int    i;
 649         char    msg[2];
 650
 651         if ( data != NULL && data->dptr == NULL ) {
 652                 msg[0] = c;
 653                 msg[1] = '\0';
 654
 655                 if ( ldbm_errno( dbp ) == 0 )
 656                         perror( msg );
 657                 else
 658                         fprintf( stderr, "%s: db_errno %d\n", msg,
 659                             ldbm_errno( dbp ) );
 660                 return;
 661         }
 662
 663         switch ( c ) {
 664         case 'd':       /* dn2id - key is dn, data is dnid */
 665                 if ( key != NULL )
 666                         fprintf( fp, "%s%s (len %d)\n", klabel, key->dptr,
 667                             key->dsize );
 668                 if ( data != NULL ) {
 669                         SAFEMEMCPY( (char *) &id, data->dptr, sizeof(ID) );
 670                         fprintf( fp, "%s%ld\n", dlabel ? dlabel : "", id );
 671                 }
 672                 break;
 673
 674         case 'e':       /* id2entry - key is dnid, data is entry */
 675                 if ( key != NULL ) {
 676                         SAFEMEMCPY( (char *) &id, key->dptr, sizeof(ID) );
 677                         fprintf( fp, "%s %ld\n", klabel, id );
 678                 }
 679                 if ( data != NULL ) {
 680                         if ( dlabel ) {
 681                                 fprintf( fp, "data length: %d\n", data->dsize );
 682                                 fputs( dlabel, fp );
 683                         }
 684                         fputs( data->dptr, fp );
 685                 }
 686                 break;
 687
 688         case 'c':
 689         case 'i':       /* index - key is string, data is dnid[] */
 690                 if ( key != NULL )
 691                         fprintf( fp, "%s%s (len %d)\n", klabel, key->dptr,
 692                             key->dsize );
 693                 if ( data != NULL ) {
 694                         idl = (ID_BLOCK *) data->dptr;
 695
 696                         if ( dlabel )
 697                                 fprintf( fp, "%s\tnmax=%ld\n\tncur=%ld\n", dlabel,
 698                                     ID_BLOCK_NMAX(idl), ID_BLOCK_NIDS(idl) );
 699
 700                         if ( ID_BLOCK_INDIRECT( idl ) ) {
 701                                 for ( i = 0; !ID_BLOCK_NOID(idl, i); i++ ) {
 702                                         fprintf( fp, "\t%ld\n", ID_BLOCK_ID(idl, i) );
 703                                 }
 704                         } else if ( ID_BLOCK_ALLIDS( idl ) ) {
 705                                 fprintf( fp, "\tALLIDS (1..%ld)\n",
 706                                     ID_BLOCK_NIDS(idl) - 1 );
 707                         } else {
 708                                 for ( i = 0; i < ID_BLOCK_NIDS(idl); i++ ) {
 709                                         fprintf( fp, "\t%ld\n", ID_BLOCK_ID(idl,i) );
 710                                 }
 711                         }
 712                 }
 713                 break;
 714
 715         case 'f':       /* arbitrary file - assume key & data are strings */
 716                 if ( key != NULL )
 717                         fprintf( fp, "%s%s\n", klabel, key->dptr );
 718                 if ( data != NULL ) {
 719                         fprintf( fp, "%s%s\n", dlabel ? dlabel : "",
 720                             data->dptr );
 721                 }
 722                 break;
 723
 724         default:
 725                 fprintf( stderr, "specify [deci] to select a file\n" );
 726                 break;
 727         }
 728 }
 729
 730 static void
 731 get_keydata( FILE *fp, char c, Datum *key, Datum *data )
 732 {
 733         static char     kbuf[BUFSIZ], dbuf[BUFSIZ];
 734         long            n;
 735         int             fd, tty;
 736
 737         fd = fileno( fp );
 738         tty = isatty( fd );
 739
 740         switch ( c ) {
 741         case 'd':       /* dn2id - key is dn, data is dnid */
 742                 if ( key != NULL ) {
 743                         if ( tty )
 744                                 printf( "  dn: " );
 745                         if ( fgets( kbuf, sizeof(kbuf), fp ) == NULL ) {
 746                                 exit( EXIT_SUCCESS );
 747                         }
 748                         kbuf[strlen( kbuf ) - 1] = '\0';
 749                         key->dptr = strdup( kbuf );
 750                         key->dsize = strlen( kbuf ) + 1;
 751                 }
 752
 753                 if ( data != NULL ) {
 754                         if ( tty )
 755                                 printf( "  dnid: " );
 756                         if ( fgets( dbuf, sizeof(dbuf), fp ) == NULL ) {
 757                                 exit( EXIT_SUCCESS );
 758                         }
 759                         n = atol( dbuf );
 760                         data->dptr = (char *) malloc( sizeof(n) );
 761                         memcpy( data->dptr, (char *) &n, sizeof(n) );
 762                         data->dsize = sizeof(n);
 763                 }
 764                 break;
 765
 766         case 'e':       /* id2entry - key is dnid, data is entry */
 767                 if ( key != NULL ) {
 768                         if ( tty )
 769                                 printf( "  dnid: " );
 770                         if ( fgets( kbuf, sizeof(kbuf), fp ) == NULL ) {
 771                                 exit( EXIT_SUCCESS );
 772                         }
 773                         n = atol( kbuf );
 774                         key->dptr = (char *) malloc( sizeof(n) );
 775                         memcpy( key->dptr, (char *) &n, sizeof(n) );
 776                         key->dsize = sizeof(n);
 777                 }
 778
 779                 if ( data != NULL ) {
 780                         get_entry( fp, data );
 781                 }
 782                 break;
 783
 784         case 'c':       /* id2children - key is string dnid, data is dnid[] */
 785         case 'i':       /* index - key is string, data is dnid[] */
 786                 if ( key != NULL ) {
 787                         if ( tty )
 788                                 printf( "  key: " );
 789                         if ( fgets( kbuf, sizeof(kbuf), fp ) == NULL ) {
 790                                 exit( EXIT_SUCCESS );
 791                         }
 792                         kbuf[strlen( kbuf ) - 1] = '\0';
 793                         key->dptr = strdup( kbuf );
 794                         key->dsize = strlen( kbuf ) + 1;
 795                 }
 796
 797                 if ( data != NULL ) {
 798                         get_idlist( fp, data );
 799                 }
 800                 break;
 801
 802         default:
 803                 fprintf(stderr, "specify [deci] to select file type\n");
 804                 break;
 805         }
 806 }
 807