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