git.sur5r.net Git - openldap/blob - clients/tools/ldapmodify.c

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /* ldapmodify.c - generic program to modify or add entries using LDAP */
   6
   7 #include "portable.h"
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/signal.h>
  14 #include <ac/string.h>
  15 #include <ac/unistd.h>
  16
  17 #include <sys/stat.h>
  18
  19 #ifdef HAVE_SYS_FILE_H
  20 #include <sys/file.h>
  21 #endif
  22 #ifdef HAVE_FCNTL_H
  23 #include <fcntl.h>
  24 #endif
  25
  26 #include <lber.h>
  27 #include <ldap.h>
  28 #include <ldif.h>
  29
  30 static char     *prog;
  31 static char     *binddn = NULL;
  32 static char     *passwd = NULL;
  33 static char     *ldaphost = NULL;
  34 static int      ldapport = 0;
  35 static int      new, replace, not, verbose, contoper, force, valsfromfiles;
  36 static LDAP     *ld;
  37
  38 #define LDAPMOD_MAXLINE         4096
  39
  40 /* strings found in replog/LDIF entries (mostly lifted from slurpd/slurp.h) */
  41 #define T_REPLICA_STR           "replica"
  42 #define T_DN_STR                "dn"
  43 #define T_CHANGETYPESTR         "changetype"
  44 #define T_ADDCTSTR              "add"
  45 #define T_MODIFYCTSTR           "modify"
  46 #define T_DELETECTSTR           "delete"
  47 #define T_MODRDNCTSTR           "modrdn"
  48 #define T_MODOPADDSTR           "add"
  49 #define T_MODOPREPLACESTR       "replace"
  50 #define T_MODOPDELETESTR        "delete"
  51 #define T_MODSEPSTR             "-"
  52 #define T_NEWRDNSTR             "newrdn"
  53 #define T_DELETEOLDRDNSTR       "deleteoldrdn"
  54
  55
  56 static void usage LDAP_P(( const char *prog ));
  57 static int process_ldapmod_rec LDAP_P(( char *rbuf ));
  58 static int process_ldif_rec LDAP_P(( char *rbuf ));
  59 static void addmodifyop LDAP_P(( LDAPMod ***pmodsp, int modop, char *attr,
  60         char *value, int vlen ));
  61 static int domodify LDAP_P(( char *dn, LDAPMod **pmods, int newentry ));
  62 static int dodelete LDAP_P(( char *dn ));
  63 static int domodrdn LDAP_P(( char *dn, char *newrdn, int deleteoldrdn ));
  64 static void freepmods LDAP_P(( LDAPMod **pmods ));
  65 static int fromfile LDAP_P(( char *path, struct berval *bv ));
  66 static char *read_one_record LDAP_P(( FILE *fp ));
  67
  68 static void
  69 usage( const char *prog )
  70 {
  71     fprintf( stderr, "Add or modify entries from an LDAP server\n\n"
  72              "usage: %s [-abcknrvF] [-d debug-level] [-P version] [-h ldaphost]\n"
  73              "            [-p ldapport] [-D binddn] [-w passwd] [ -f file | < entryfile ]\n"
  74              "       a    - add values (default%s)\n"
  75              "       b    - read values from files (for binary attributes)\n"
  76              "       c    - continuous operation\n"
  77              "       D    - bind DN\n"
  78              "       d    - debug level\n"
  79              "       f    - read from file\n"
  80              "       F    - force all changes records to be used\n"
  81              "       h    - ldap host\n"
  82              "       n    - print adds, don't actually do them\n"
  83              "       p    - LDAP port\n"
  84              "       r    - replace values\n"
  85              "       v    - verbose mode\n"
  86              "       w    - password\n"
  87              , prog, (strcmp( prog, "ldapadd" ) ? " is to replace" : "") );
  88     exit( 1 );
  89 }
  90
  91
  92 int
  93 main( int argc, char **argv )
  94 {
  95     char                *infile, *rbuf, *start, *p, *q;
  96     FILE                *fp;
  97         int             rc, i, use_ldif, authmethod, version, want_bindpw, debug;
  98
  99     if (( prog = strrchr( argv[ 0 ], '/'  )) == NULL &&
 100         ( prog = strrchr( argv[ 0 ], '\\' )) == NULL   ) { /*for Windows/DOS*/
 101         prog = argv[ 0 ];
 102     } else {
 103         ++prog;
 104     }
 105
 106     /* Print usage when no parameters */
 107     if( argc < 2 )
 108         usage( prog );
 109
 110     new = ( strcmp( prog, "ldapadd" ) == 0 );
 111
 112     infile = NULL;
 113     not = verbose = valsfromfiles = want_bindpw = debug = 0;
 114     authmethod = LDAP_AUTH_SIMPLE;
 115         version = -1;
 116
 117     while (( i = getopt( argc, argv, "WFabckKnrtvh:p:D:w:d:f:" )) != EOF ) {
 118         switch( i ) {
 119         case 'a':       /* add */
 120             new = 1;
 121             break;
 122         case 'b':       /* read values from files (for binary attributes) */
 123             valsfromfiles = 1;
 124             break;
 125         case 'c':       /* continuous operation */
 126             contoper = 1;
 127             break;
 128         case 'r':       /* default is to replace rather than add values */
 129             replace = 1;
 130             break;
 131         case 'k':       /* kerberos bind */
 132 #ifdef HAVE_KERBEROS
 133                 authmethod = LDAP_AUTH_KRBV4;
 134 #else
 135                 fprintf (stderr, "%s was not compiled with Kerberos support\n", argv[0]);
 136 #endif
 137             break;
 138         case 'K':       /* kerberos bind, part 1 only */
 139 #ifdef HAVE_KERBEROS
 140                 authmethod = LDAP_AUTH_KRBV41;
 141 #else
 142                 fprintf (stderr, "%s was not compiled with Kerberos support\n", argv[0]);
 143 #endif
 144             break;
 145         case 'F':       /* force all changes records to be used */
 146             force = 1;
 147             break;
 148         case 'h':       /* ldap host */
 149             ldaphost = strdup( optarg );
 150             break;
 151         case 'D':       /* bind DN */
 152             binddn = strdup( optarg );
 153             break;
 154         case 'w':       /* password */
 155             passwd = strdup( optarg );
 156             break;
 157         case 'd':
 158             debug |= atoi( optarg );
 159             break;
 160         case 'f':       /* read from file */
 161             infile = strdup( optarg );
 162             break;
 163         case 'p':
 164             ldapport = atoi( optarg );
 165             break;
 166         case 'n':       /* print adds, don't actually do them */
 167             ++not;
 168             break;
 169         case 'v':       /* verbose mode */
 170             verbose++;
 171             break;
 172         case 'W':
 173                 want_bindpw++;
 174                 break;
 175         case 'P':
 176                 switch(optarg[0])
 177                 {
 178                 case '2':
 179                         version = LDAP_VERSION2;
 180                         break;
 181                 case '3':
 182                         version = LDAP_VERSION3;
 183                         break;
 184                 }
 185                 break;
 186         default:
 187             usage( prog );
 188         }
 189     }
 190
 191     if ( argc != optind )
 192         usage( prog );
 193
 194     if ( infile != NULL ) {
 195         if (( fp = fopen( infile, "r" )) == NULL ) {
 196             perror( infile );
 197             exit( 1 );
 198         }
 199     } else {
 200         fp = stdin;
 201     }
 202
 203         if ( debug ) {
 204                 ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &debug );
 205                 ldap_set_option( NULL, LDAP_OPT_DEBUG_LEVEL, &debug );
 206                 ldif_debug = debug;
 207         }
 208
 209 #ifdef SIGPIPE
 210         (void) SIGNAL( SIGPIPE, SIG_IGN );
 211 #endif
 212
 213     if ( !not ) {
 214         if (( ld = ldap_init( ldaphost, ldapport )) == NULL ) {
 215             perror( "ldap_init" );
 216             exit( 1 );
 217         }
 218
 219         /* this seems prudent */
 220         {
 221                 int deref = LDAP_DEREF_NEVER;
 222                 ldap_set_option( ld, LDAP_OPT_DEREF, &deref);
 223         }
 224
 225         if (want_bindpw)
 226                 passwd = getpass("Enter LDAP Password: ");
 227
 228         if( version != -1 ) {
 229                 ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
 230         }
 231
 232         if ( ldap_bind_s( ld, binddn, passwd, authmethod ) != LDAP_SUCCESS ) {
 233             ldap_perror( ld, "ldap_bind" );
 234             exit( 1 );
 235         }
 236     }
 237
 238     rc = 0;
 239
 240     while (( rc == 0 || contoper ) &&
 241                 ( rbuf = read_one_record( fp )) != NULL ) {
 242         /*
 243          * we assume record is ldif/slapd.replog if the first line
 244          * has a colon that appears to the left of any equal signs, OR
 245          * if the first line consists entirely of digits (an entry id)
 246          */
 247         use_ldif = ( p = strchr( rbuf, ':' )) != NULL &&
 248                 ( q = strchr( rbuf, '\n' )) != NULL && p < q &&
 249                 (( q = strchr( rbuf, '=' )) == NULL || p < q );
 250
 251         start = rbuf;
 252
 253         if ( !use_ldif && ( q = strchr( rbuf, '\n' )) != NULL ) {
 254             for ( p = rbuf; p < q; ++p ) {
 255                 if ( !isdigit( (unsigned char) *p )) {
 256                     break;
 257                 }
 258             }
 259             if ( p >= q ) {
 260                 use_ldif = 1;
 261                 start = q + 1;
 262             }
 263         }
 264
 265         if ( use_ldif ) {
 266             rc = process_ldif_rec( start );
 267         } else {
 268             rc = process_ldapmod_rec( start );
 269         }
 270
 271         if( rc )
 272             fprintf( stderr, "%s() = %d\n",
 273                      use_ldif ? "ldif_rec" : "ldapmod_rec" , rc );
 274
 275         free( rbuf );
 276     }
 277
 278     if ( !not ) {
 279         ldap_unbind( ld );
 280     }
 281
 282     exit( rc );
 283
 284         /* UNREACHABLE */
 285         return(0);
 286 }
 287
 288
 289 static int
 290 process_ldif_rec( char *rbuf )
 291 {
 292     char        *line, *dn, *type, *value, *newrdn, *p;
 293     int         rc, linenum, vlen, modop, replicaport;
 294     int         expect_modop, expect_sep, expect_ct, expect_newrdn;
 295     int         expect_deleteoldrdn, deleteoldrdn;
 296     int         saw_replica, use_record, new_entry, delete_entry, got_all;
 297     LDAPMod     **pmods;
 298
 299     new_entry = new;
 300
 301     rc = got_all = saw_replica = delete_entry = expect_modop = 0;
 302     expect_deleteoldrdn = expect_newrdn = expect_sep = expect_ct = 0;
 303     linenum = 0;
 304     deleteoldrdn = 1;
 305     use_record = force;
 306     pmods = NULL;
 307     dn = newrdn = NULL;
 308
 309     while ( rc == 0 && ( line = ldif_getline( &rbuf )) != NULL ) {
 310         ++linenum;
 311         if ( expect_sep && strcasecmp( line, T_MODSEPSTR ) == 0 ) {
 312             expect_sep = 0;
 313             expect_ct = 1;
 314             continue;
 315         }
 316
 317         if ( ldif_parse_line( line, &type, &value, &vlen ) < 0 ) {
 318             fprintf( stderr, "%s: invalid format (line %d of entry: %s\n",
 319                     prog, linenum, dn == NULL ? "" : dn );
 320             rc = LDAP_PARAM_ERROR;
 321             break;
 322         }
 323
 324         if ( dn == NULL ) {
 325             if ( !use_record && strcasecmp( type, T_REPLICA_STR ) == 0 ) {
 326                 ++saw_replica;
 327                 if (( p = strchr( value, ':' )) == NULL ) {
 328                     replicaport = 0;
 329                 } else {
 330                     *p++ = '\0';
 331                     replicaport = atoi( p );
 332                 }
 333                 if ( strcasecmp( value, ldaphost ) == 0 &&
 334                         replicaport == ldapport ) {
 335                     use_record = 1;
 336                 }
 337             } else if ( strcasecmp( type, T_DN_STR ) == 0 ) {
 338                 if (( dn = strdup( value )) == NULL ) {
 339                     perror( "strdup" );
 340                     exit( 1 );
 341                 }
 342                 expect_ct = 1;
 343             }
 344             continue;   /* skip all lines until we see "dn:" */
 345         }
 346
 347         if ( expect_ct ) {
 348             expect_ct = 0;
 349             if ( !use_record && saw_replica ) {
 350                 printf( "%s: skipping change record for entry: %s\n\t(LDAP host/port does not match replica: lines)\n",
 351                         prog, dn );
 352                 free( dn );
 353                 return( 0 );
 354             }
 355
 356             if ( strcasecmp( type, T_CHANGETYPESTR ) == 0 ) {
 357                 if ( strcasecmp( value, T_MODIFYCTSTR ) == 0 ) {
 358                         new_entry = 0;
 359                         expect_modop = 1;
 360                 } else if ( strcasecmp( value, T_ADDCTSTR ) == 0 ) {
 361                         new_entry = 1;
 362                 } else if ( strcasecmp( value, T_MODRDNCTSTR ) == 0 ) {
 363                     expect_newrdn = 1;
 364                 } else if ( strcasecmp( value, T_DELETECTSTR ) == 0 ) {
 365                     got_all = delete_entry = 1;
 366                 } else {
 367                     fprintf( stderr,
 368                             "%s:  unknown %s \"%s\" (line %d of entry: %s)\n",
 369                             prog, T_CHANGETYPESTR, value, linenum, dn );
 370                     rc = LDAP_PARAM_ERROR;
 371                 }
 372                 continue;
 373             } else if ( new ) {         /*  missing changetype => add */
 374                 new_entry = 1;
 375                 modop = LDAP_MOD_ADD;
 376             } else {
 377                 expect_modop = 1;       /* missing changetype => modify */
 378             }
 379         }
 380
 381         if ( expect_modop ) {
 382             expect_modop = 0;
 383             expect_sep = 1;
 384             if ( strcasecmp( type, T_MODOPADDSTR ) == 0 ) {
 385                 modop = LDAP_MOD_ADD;
 386                 continue;
 387             } else if ( strcasecmp( type, T_MODOPREPLACESTR ) == 0 ) {
 388                 modop = LDAP_MOD_REPLACE;
 389                 continue;
 390             } else if ( strcasecmp( type, T_MODOPDELETESTR ) == 0 ) {
 391                 modop = LDAP_MOD_DELETE;
 392                 addmodifyop( &pmods, modop, value, NULL, 0 );
 393                 continue;
 394             } else {    /* no modify op:  use default */
 395                 modop = replace ? LDAP_MOD_REPLACE : LDAP_MOD_ADD;
 396             }
 397         }
 398
 399         if ( expect_newrdn ) {
 400             if ( strcasecmp( type, T_NEWRDNSTR ) == 0 ) {
 401                 if (( newrdn = strdup( value )) == NULL ) {
 402                     perror( "strdup" );
 403                     exit( 1 );
 404                 }
 405                 expect_deleteoldrdn = 1;
 406                 expect_newrdn = 0;
 407             } else {
 408                 fprintf( stderr, "%s: expecting \"%s:\" but saw \"%s:\" (line %d of entry %s)\n",
 409                         prog, T_NEWRDNSTR, type, linenum, dn );
 410                 rc = LDAP_PARAM_ERROR;
 411             }
 412         } else if ( expect_deleteoldrdn ) {
 413             if ( strcasecmp( type, T_DELETEOLDRDNSTR ) == 0 ) {
 414                 deleteoldrdn = ( *value == '0' ) ? 0 : 1;
 415                 got_all = 1;
 416             } else {
 417                 fprintf( stderr, "%s: expecting \"%s:\" but saw \"%s:\" (line %d of entry %s)\n",
 418                         prog, T_DELETEOLDRDNSTR, type, linenum, dn );
 419                 rc = LDAP_PARAM_ERROR;
 420             }
 421         } else if ( got_all ) {
 422             fprintf( stderr,
 423                     "%s: extra lines at end (line %d of entry %s)\n",
 424                     prog, linenum, dn );
 425             rc = LDAP_PARAM_ERROR;
 426         } else {
 427             addmodifyop( &pmods, modop, type, value, vlen );
 428         }
 429     }
 430
 431     if ( rc == 0 ) {
 432         if ( delete_entry ) {
 433             rc = dodelete( dn );
 434         } else if ( newrdn != NULL ) {
 435             rc = domodrdn( dn, newrdn, deleteoldrdn );
 436         } else {
 437             rc = domodify( dn, pmods, new_entry );
 438         }
 439
 440         if ( rc == LDAP_SUCCESS ) {
 441             rc = 0;
 442         }
 443     }
 444
 445     if ( dn != NULL ) {
 446         free( dn );
 447     }
 448     if ( newrdn != NULL ) {
 449         free( newrdn );
 450     }
 451     if ( pmods != NULL ) {
 452         freepmods( pmods );
 453     }
 454
 455     return( rc );
 456 }
 457
 458
 459 static int
 460 process_ldapmod_rec( char *rbuf )
 461 {
 462     char        *line, *dn, *p, *q, *attr, *value;
 463     int         rc, linenum, modop;
 464     LDAPMod     **pmods;
 465
 466     pmods = NULL;
 467     dn = NULL;
 468     linenum = 0;
 469     line = rbuf;
 470     rc = 0;
 471
 472     while ( rc == 0 && rbuf != NULL && *rbuf != '\0' ) {
 473         ++linenum;
 474         if (( p = strchr( rbuf, '\n' )) == NULL ) {
 475             rbuf = NULL;
 476         } else {
 477             if ( *(p-1) == '\\' ) {     /* lines ending in '\' are continued */
 478                 SAFEMEMCPY( p - 1, p, strlen( p ) + 1 );
 479                 rbuf = p;
 480                 continue;
 481             }
 482             *p++ = '\0';
 483             rbuf = p;
 484         }
 485
 486         if ( dn == NULL ) {     /* first line contains DN */
 487             if (( dn = strdup( line )) == NULL ) {
 488                 perror( "strdup" );
 489                 exit( 1 );
 490             }
 491         } else {
 492             if (( p = strchr( line, '=' )) == NULL ) {
 493                 value = NULL;
 494                 p = line + strlen( line );
 495             } else {
 496                 *p++ = '\0';
 497                 value = p;
 498             }
 499
 500             for ( attr = line;
 501                   *attr != '\0' && isspace( (unsigned char) *attr ); ++attr ) {
 502                 ;       /* skip attribute leading white space */
 503             }
 504
 505             for ( q = p - 1; q > attr && isspace( (unsigned char) *q ); --q ) {
 506                 *q = '\0';      /* remove attribute trailing white space */
 507             }
 508
 509             if ( value != NULL ) {
 510                 while ( isspace( (unsigned char) *value )) {
 511                     ++value;            /* skip value leading white space */
 512                 }
 513                 for ( q = value + strlen( value ) - 1; q > value &&
 514                         isspace( (unsigned char) *q ); --q ) {
 515                     *q = '\0';  /* remove value trailing white space */
 516                 }
 517                 if ( *value == '\0' ) {
 518                     value = NULL;
 519                 }
 520
 521             }
 522
 523             if ( value == NULL && new ) {
 524                 fprintf( stderr, "%s: missing value on line %d (attr is %s)\n",
 525                         prog, linenum, attr );
 526                 rc = LDAP_PARAM_ERROR;
 527             } else {
 528                  switch ( *attr ) {
 529                 case '-':
 530                     modop = LDAP_MOD_DELETE;
 531                     ++attr;
 532                     break;
 533                 case '+':
 534                     modop = LDAP_MOD_ADD;
 535                     ++attr;
 536                     break;
 537                 default:
 538                     modop = replace ? LDAP_MOD_REPLACE : LDAP_MOD_ADD;
 539                 }
 540
 541                 addmodifyop( &pmods, modop, attr, value,
 542                         ( value == NULL ) ? 0 : strlen( value ));
 543             }
 544         }
 545
 546         line = rbuf;
 547     }
 548
 549     if ( rc == 0 ) {
 550         if ( dn == NULL ) {
 551             rc = LDAP_PARAM_ERROR;
 552         } else if (( rc = domodify( dn, pmods, new )) == LDAP_SUCCESS ) {
 553             rc = 0;
 554         }
 555     }
 556
 557     if ( pmods != NULL ) {
 558         freepmods( pmods );
 559     }
 560     if ( dn != NULL ) {
 561         free( dn );
 562     }
 563
 564     return( rc );
 565 }
 566
 567
 568 static void
 569 addmodifyop( LDAPMod ***pmodsp, int modop, char *attr, char *value, int vlen )
 570 {
 571     LDAPMod             **pmods;
 572     int                 i, j;
 573     struct berval       *bvp;
 574
 575     pmods = *pmodsp;
 576     modop |= LDAP_MOD_BVALUES;
 577
 578     i = 0;
 579     if ( pmods != NULL ) {
 580         for ( ; pmods[ i ] != NULL; ++i ) {
 581             if ( strcasecmp( pmods[ i ]->mod_type, attr ) == 0 &&
 582                     pmods[ i ]->mod_op == modop ) {
 583                 break;
 584             }
 585         }
 586     }
 587
 588     if ( pmods == NULL || pmods[ i ] == NULL ) {
 589         if (( pmods = (LDAPMod **)realloc( pmods, (i + 2) *
 590                 sizeof( LDAPMod * ))) == NULL ) {
 591             perror( "realloc" );
 592             exit( 1 );
 593         }
 594         *pmodsp = pmods;
 595         pmods[ i + 1 ] = NULL;
 596         if (( pmods[ i ] = (LDAPMod *)calloc( 1, sizeof( LDAPMod )))
 597                 == NULL ) {
 598             perror( "calloc" );
 599             exit( 1 );
 600         }
 601         pmods[ i ]->mod_op = modop;
 602         if (( pmods[ i ]->mod_type = strdup( attr )) == NULL ) {
 603             perror( "strdup" );
 604             exit( 1 );
 605         }
 606     }
 607
 608     if ( value != NULL ) {
 609         j = 0;
 610         if ( pmods[ i ]->mod_bvalues != NULL ) {
 611             for ( ; pmods[ i ]->mod_bvalues[ j ] != NULL; ++j ) {
 612                 ;
 613             }
 614         }
 615         if (( pmods[ i ]->mod_bvalues =
 616                 (struct berval **)ber_memrealloc( pmods[ i ]->mod_bvalues,
 617                 (j + 2) * sizeof( struct berval * ))) == NULL ) {
 618             perror( "ber_realloc" );
 619             exit( 1 );
 620         }
 621         pmods[ i ]->mod_bvalues[ j + 1 ] = NULL;
 622         if (( bvp = (struct berval *)ber_memalloc( sizeof( struct berval )))
 623                 == NULL ) {
 624             perror( "ber_memalloc" );
 625             exit( 1 );
 626         }
 627         pmods[ i ]->mod_bvalues[ j ] = bvp;
 628
 629         if ( valsfromfiles && *value == '/' ) { /* get value from file */
 630             if ( fromfile( value, bvp ) < 0 ) {
 631                 exit( 1 );
 632             }
 633         } else {
 634             bvp->bv_len = vlen;
 635             if (( bvp->bv_val = (char *)malloc( vlen + 1 )) == NULL ) {
 636                 perror( "malloc" );
 637                 exit( 1 );
 638             }
 639             SAFEMEMCPY( bvp->bv_val, value, vlen );
 640             bvp->bv_val[ vlen ] = '\0';
 641         }
 642     }
 643 }
 644
 645
 646 static int
 647 domodify( char *dn, LDAPMod **pmods, int newentry )
 648 {
 649     int                 i, j, k, notascii, op;
 650     struct berval       *bvp;
 651
 652     if ( pmods == NULL ) {
 653         fprintf( stderr, "%s: no attributes to change or add (entry %s)\n",
 654                 prog, dn );
 655         return( LDAP_PARAM_ERROR );
 656     }
 657
 658     if ( verbose ) {
 659         for ( i = 0; pmods[ i ] != NULL; ++i ) {
 660             op = pmods[ i ]->mod_op & ~LDAP_MOD_BVALUES;
 661             printf( "%s %s:\n", op == LDAP_MOD_REPLACE ?
 662                     "replace" : op == LDAP_MOD_ADD ?
 663                     "add" : "delete", pmods[ i ]->mod_type );
 664             if ( pmods[ i ]->mod_bvalues != NULL ) {
 665                 for ( j = 0; pmods[ i ]->mod_bvalues[ j ] != NULL; ++j ) {
 666                     bvp = pmods[ i ]->mod_bvalues[ j ];
 667                     notascii = 0;
 668                     for ( k = 0; (unsigned long) k < bvp->bv_len; ++k ) {
 669                         if ( !isascii( bvp->bv_val[ k ] )) {
 670                             notascii = 1;
 671                             break;
 672                         }
 673                     }
 674                     if ( notascii ) {
 675                         printf( "\tNOT ASCII (%ld bytes)\n", bvp->bv_len );
 676                     } else {
 677                         printf( "\t%s\n", bvp->bv_val );
 678                     }
 679                 }
 680             }
 681         }
 682     }
 683
 684     if ( newentry ) {
 685         printf( "%sadding new entry %s\n", not ? "!" : "", dn );
 686     } else {
 687         printf( "%smodifying entry %s\n", not ? "!" : "", dn );
 688     }
 689
 690     if ( !not ) {
 691         if ( newentry ) {
 692             i = ldap_add_s( ld, dn, pmods );
 693         } else {
 694             i = ldap_modify_s( ld, dn, pmods );
 695         }
 696         if ( i != LDAP_SUCCESS ) {
 697             ldap_perror( ld, newentry ? "ldap_add" : "ldap_modify" );
 698         } else if ( verbose ) {
 699             printf( "modify complete\n" );
 700         }
 701     } else {
 702         i = LDAP_SUCCESS;
 703     }
 704
 705     putchar( '\n' );
 706
 707     return( i );
 708 }
 709
 710
 711 static int
 712 dodelete( char *dn )
 713 {
 714     int rc;
 715
 716     printf( "%sdeleting entry %s\n", not ? "!" : "", dn );
 717     if ( !not ) {
 718         if (( rc = ldap_delete_s( ld, dn )) != LDAP_SUCCESS ) {
 719             ldap_perror( ld, "ldap_delete" );
 720         } else if ( verbose ) {
 721             printf( "delete complete" );
 722         }
 723     } else {
 724         rc = LDAP_SUCCESS;
 725     }
 726
 727     putchar( '\n' );
 728
 729     return( rc );
 730 }
 731
 732
 733 static int
 734 domodrdn( char *dn, char *newrdn, int deleteoldrdn )
 735 {
 736     int rc;
 737
 738     if ( verbose ) {
 739         printf( "new RDN: %s (%skeep existing values)\n",
 740                 newrdn, deleteoldrdn ? "do not " : "" );
 741     }
 742
 743     printf( "%smodifying rdn of entry %s\n", not ? "!" : "", dn );
 744     if ( !not ) {
 745         if (( rc = ldap_modrdn2_s( ld, dn, newrdn, deleteoldrdn ))
 746                 != LDAP_SUCCESS ) {
 747             ldap_perror( ld, "ldap_modrdn" );
 748         } else {
 749             printf( "modrdn completed\n" );
 750         }
 751     } else {
 752         rc = LDAP_SUCCESS;
 753     }
 754
 755     putchar( '\n' );
 756
 757     return( rc );
 758 }
 759
 760
 761
 762 static void
 763 freepmods( LDAPMod **pmods )
 764 {
 765     int i;
 766
 767     for ( i = 0; pmods[ i ] != NULL; ++i ) {
 768         if ( pmods[ i ]->mod_bvalues != NULL ) {
 769             ber_bvecfree( pmods[ i ]->mod_bvalues );
 770         }
 771         if ( pmods[ i ]->mod_type != NULL ) {
 772             free( pmods[ i ]->mod_type );
 773         }
 774         free( pmods[ i ] );
 775     }
 776     free( pmods );
 777 }
 778
 779
 780 static int
 781 fromfile( char *path, struct berval *bv )
 782 {
 783         FILE            *fp;
 784         long            rlen;
 785         int             eof;
 786
 787         if (( fp = fopen( path, "r" )) == NULL ) {
 788                 perror( path );
 789                 return( -1 );
 790         }
 791
 792         if ( fseek( fp, 0L, SEEK_END ) != 0 ) {
 793                 perror( path );
 794                 fclose( fp );
 795                 return( -1 );
 796         }
 797
 798         bv->bv_len = ftell( fp );
 799
 800         if (( bv->bv_val = (char *)malloc( bv->bv_len )) == NULL ) {
 801                 perror( "malloc" );
 802                 fclose( fp );
 803                 return( -1 );
 804         }
 805
 806         if ( fseek( fp, 0L, SEEK_SET ) != 0 ) {
 807                 perror( path );
 808                 fclose( fp );
 809                 return( -1 );
 810         }
 811
 812         rlen = fread( bv->bv_val, 1, bv->bv_len, fp );
 813         eof = feof( fp );
 814         fclose( fp );
 815
 816         if ( (unsigned long) rlen != bv->bv_len ) {
 817                 perror( path );
 818                 free( bv->bv_val );
 819                 return( -1 );
 820         }
 821
 822         return( bv->bv_len );
 823 }
 824
 825
 826 static char *
 827 read_one_record( FILE *fp )
 828 {
 829     int         len;
 830     char        *buf, line[ LDAPMOD_MAXLINE ];
 831     int         lcur, lmax;
 832
 833     lcur = lmax = 0;
 834     buf = NULL;
 835
 836     while (( fgets( line, sizeof(line), fp ) != NULL ) &&
 837             (( len = strlen( line )) > 1 )) {
 838         if ( lcur + len + 1 > lmax ) {
 839             lmax = LDAPMOD_MAXLINE
 840                     * (( lcur + len + 1 ) / LDAPMOD_MAXLINE + 1 );
 841             if (( buf = (char *)realloc( buf, lmax )) == NULL ) {
 842                 perror( "realloc" );
 843                 exit( 1 );
 844             }
 845         }
 846         strcpy( buf + lcur, line );
 847         lcur += len;
 848     }
 849
 850     return( buf );
 851 }