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