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