git.sur5r.net Git - openldap/blob - servers/slapd/tools/ldbmtest.c

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