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