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

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