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