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

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