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