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

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