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

   1 /* ldapdelete.c - simple program to delete an entry using LDAP */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/stdlib.h>
  13 #include <ac/ctype.h>
  14
  15 #include <ac/signal.h>
  16 #include <ac/string.h>
  17 #include <ac/unistd.h>
  18
  19 #include <ldap.h>
  20
  21 static char     *binddn = NULL;
  22 static struct berval passwd = { 0, NULL};
  23 static char     *ldaphost = NULL;
  24 static int      ldapport = 0;
  25 static int      prune = 0;
  26 #ifdef HAVE_CYRUS_SASL
  27 static char     *sasl_authc_id = NULL;
  28 static char     *sasl_authz_id = NULL;
  29 static char     *sasl_mech = NULL;
  30 static int      sasl_integrity = 0;
  31 static int      sasl_privacy = 0;
  32 #endif
  33 static int      use_tls = 0;
  34 static int      not, verbose, contoper;
  35 static LDAP     *ld;
  36
  37 static int dodelete LDAP_P((
  38     LDAP *ld,
  39     const char *dn));
  40
  41 static int deletechildren LDAP_P((
  42         LDAP *ld,
  43         const char *dn ));
  44
  45 static void
  46 usage( const char *s )
  47 {
  48         fprintf( stderr,
  49 "Delete entries from an LDAP server\n\n"
  50 "usage: %s [options] [dn]...\n"
  51 "       dn: list of DNs to delete. If not given, it will be readed from stdin\n"
  52 "           or from the file specified with \"-f file\".\n"
  53 "options:\n"
  54 "       -c\t\tcontinuous operation mode (do not stop on errors)\n"
  55 "       -C\t\tchase referrals\n"
  56 "       -d level\tset LDAP debugging level to `level'\n"
  57 "       -D binddn\tbind DN\n"
  58 "       -E\t\trequest SASL privacy (-EE to make it critical)\n"
  59 "       -f file\t\tdelete DNs listed in `file'\n"
  60 "       -h host\t\tLDAP server\n"
  61 "       -I\t\trequest SASL integrity checking (-II to make it\n"
  62 "               \tcritical)\n"
  63 "       -k\t\tuse Kerberos authentication\n"
  64 "       -K\t\tlike -k, but do only step 1 of the Kerberos bind\n"
  65 "       -M\t\tenable Manage DSA IT control (-MM to make it critical)\n"
  66 "       -n\t\tshow what would be done but don't actually delete\n"
  67 "       -p port\t\tport on LDAP server\n"
  68 "       -P version\tprocotol version (default: 3)\n"
  69 "       -r\t\tdelete recursively\n"
  70 "       -U user\t\tSASL authentication identity (username)\n"
  71 "       -v\t\trun in verbose mode (diagnostics to standard output)\n"
  72 "       -w passwd\tbind passwd (for simple authentication)\n"
  73 "       -W\t\tprompt for bind passwd\n"
  74 "       -X id\t\tSASL authorization identity (\"dn:<dn>\" or \"u:<user>\")\n"
  75 "       -Y mech\t\tSASL mechanism\n"
  76 "       -Z\t\tissue Start TLS request (-ZZ to require successful response)\n"
  77 ,               s );
  78
  79         exit( EXIT_FAILURE );
  80 }
  81
  82
  83 int
  84 main( int argc, char **argv )
  85 {
  86         char            buf[ 4096 ];
  87         FILE            *fp;
  88         int             i, rc, authmethod, referrals, want_bindpw, version, debug, manageDSAit;
  89
  90     not = verbose = contoper = want_bindpw = debug = manageDSAit = referrals = 0;
  91     fp = NULL;
  92     authmethod = LDAP_AUTH_SIMPLE;
  93         version = -1;
  94
  95     while (( i = getopt( argc, argv, "cCD:d:Ef:h:IKMnP:p:rU:vWw:X:Y:Z" )) != EOF ) {
  96         switch( i ) {
  97         case 'k':       /* kerberos bind */
  98 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
  99                 authmethod = LDAP_AUTH_KRBV4;
 100 #else
 101                 fprintf( stderr, "%s was not compiled with Kerberos support\n", argv[0] );
 102                 return( EXIT_FAILURE );
 103 #endif
 104             break;
 105         case 'K':       /* kerberos bind, part one only */
 106 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
 107                 authmethod = LDAP_AUTH_KRBV41;
 108 #else
 109                 fprintf( stderr, "%s was not compiled with Kerberos support\n", argv[0] );
 110                 return( EXIT_FAILURE );
 111 #endif
 112             break;
 113         case 'c':       /* continuous operation mode */
 114             ++contoper;
 115             break;
 116         case 'C':
 117                 referrals++;
 118                 break;
 119         case 'h':       /* ldap host */
 120             ldaphost = strdup( optarg );
 121             break;
 122         case 'D':       /* bind DN */
 123             binddn = strdup( optarg );
 124             break;
 125         case 'w':       /* password */
 126             passwd.bv_val = strdup( optarg );
 127                 {
 128                         char* p;
 129
 130                         for( p = optarg; *p == '\0'; p++ ) {
 131                                 *p = '*';
 132                         }
 133                 }
 134                 passwd.bv_len = strlen( passwd.bv_val );
 135             break;
 136         case 'f':       /* read DNs from a file */
 137             if (( fp = fopen( optarg, "r" )) == NULL ) {
 138                 perror( optarg );
 139                 exit( EXIT_FAILURE );
 140             }
 141             break;
 142         case 'd':
 143             debug |= atoi( optarg );
 144             break;
 145         case 'p':
 146             ldapport = atoi( optarg );
 147             break;
 148         case 'n':       /* print deletes, don't actually do them */
 149             ++not;
 150             break;
 151         case 'r':
 152                 prune = 1;
 153                 break;
 154         case 'v':       /* verbose mode */
 155             verbose++;
 156             break;
 157         case 'M':
 158                 /* enable Manage DSA IT */
 159                 manageDSAit++;
 160                 break;
 161         case 'W':
 162                 want_bindpw++;
 163                 break;
 164         case 'P':
 165                 switch( atoi(optarg) )
 166                 {
 167                 case 2:
 168                         version = LDAP_VERSION2;
 169                         break;
 170                 case 3:
 171                         version = LDAP_VERSION3;
 172                         break;
 173                 default:
 174                         fprintf( stderr, "protocol version should be 2 or 3\n" );
 175                         usage( argv[0] );
 176                         return( EXIT_FAILURE );
 177                 }
 178                 break;
 179         case 'I':
 180 #ifdef HAVE_CYRUS_SASL
 181                 sasl_integrity++;
 182                 authmethod = LDAP_AUTH_SASL;
 183 #else
 184                 fprintf( stderr, "%s was not compiled with SASL support\n",
 185                         argv[0] );
 186                 return( EXIT_FAILURE );
 187 #endif
 188                 break;
 189         case 'E':
 190 #ifdef HAVE_CYRUS_SASL
 191                 sasl_privacy++;
 192                 authmethod = LDAP_AUTH_SASL;
 193 #else
 194                 fprintf( stderr, "%s was not compiled with SASL support\n",
 195                         argv[0] );
 196                 return( EXIT_FAILURE );
 197 #endif
 198                 break;
 199         case 'Y':
 200 #ifdef HAVE_CYRUS_SASL
 201                 if ( strcasecmp( optarg, "any" ) && strcmp( optarg, "*" ) ) {
 202                         sasl_mech = strdup( optarg );
 203                 }
 204                 authmethod = LDAP_AUTH_SASL;
 205 #else
 206                 fprintf( stderr, "%s was not compiled with SASL support\n",
 207                         argv[0] );
 208                 return( EXIT_FAILURE );
 209 #endif
 210                 break;
 211         case 'U':
 212 #ifdef HAVE_CYRUS_SASL
 213                 sasl_authc_id = strdup( optarg );
 214                 authmethod = LDAP_AUTH_SASL;
 215 #else
 216                 fprintf( stderr, "%s was not compiled with SASL support\n",
 217                         argv[0] );
 218                 return( EXIT_FAILURE );
 219 #endif
 220                 break;
 221         case 'X':
 222 #ifdef HAVE_CYRUS_SASL
 223                 sasl_authz_id = strdup( optarg );
 224                 authmethod = LDAP_AUTH_SASL;
 225 #else
 226                 fprintf( stderr, "%s was not compiled with SASL support\n",
 227                         argv[0] );
 228                 return( EXIT_FAILURE );
 229 #endif
 230                 break;
 231         case 'Z':
 232 #ifdef HAVE_TLS
 233                 use_tls++;
 234 #else
 235                 fprintf( stderr, "%s was not compiled with TLS support\n",
 236                         argv[0] );
 237                 return( EXIT_FAILURE );
 238 #endif
 239                 break;
 240         default:
 241                 usage( argv[0] );
 242                 return( EXIT_FAILURE );
 243         }
 244     }
 245
 246         if ( ( authmethod == LDAP_AUTH_KRBV4 ) || ( authmethod ==
 247                         LDAP_AUTH_KRBV41 ) ) {
 248                 if( version > LDAP_VERSION2 ) {
 249                         fprintf( stderr, "Kerberos requires LDAPv2\n" );
 250                         return( EXIT_FAILURE );
 251                 }
 252                 version = LDAP_VERSION2;
 253         }
 254         else if ( authmethod == LDAP_AUTH_SASL ) {
 255                 if( version != -1 && version != LDAP_VERSION3 ) {
 256                         fprintf( stderr, "SASL requires LDAPv3\n" );
 257                         return( EXIT_FAILURE );
 258                 }
 259                 version = LDAP_VERSION3;
 260         }
 261
 262         if( manageDSAit ) {
 263                 if( version != -1 && version != LDAP_VERSION3 ) {
 264                         fprintf(stderr, "manage DSA control requires LDAPv3\n");
 265                         return EXIT_FAILURE;
 266                 }
 267                 version = LDAP_VERSION3;
 268         }
 269
 270         if( use_tls ) {
 271                 if( version != -1 && version != LDAP_VERSION3 ) {
 272                         fprintf(stderr, "Start TLS requires LDAPv3\n");
 273                         return EXIT_FAILURE;
 274                 }
 275                 version = LDAP_VERSION3;
 276         }
 277
 278     if ( fp == NULL ) {
 279         if ( optind >= argc ) {
 280             fp = stdin;
 281         }
 282     }
 283
 284         if ( debug ) {
 285                 if( ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &debug ) != LBER_OPT_SUCCESS ) {
 286                         fprintf( stderr, "Could not set LBER_OPT_DEBUG_LEVEL %d\n", debug );
 287                 }
 288                 if( ldap_set_option( NULL, LDAP_OPT_DEBUG_LEVEL, &debug ) != LDAP_OPT_SUCCESS ) {
 289                         fprintf( stderr, "Could not set LDAP_OPT_DEBUG_LEVEL %d\n", debug );
 290                 }
 291         }
 292
 293 #ifdef SIGPIPE
 294         (void) SIGNAL( SIGPIPE, SIG_IGN );
 295 #endif
 296
 297     if (( ld = ldap_init( ldaphost, ldapport )) == NULL ) {
 298                 perror( "ldap_init" );
 299                 return( EXIT_FAILURE );
 300     }
 301
 302         {
 303                 /* this seems prudent for searches below */
 304                 int deref = LDAP_DEREF_NEVER;
 305                 ldap_set_option( ld, LDAP_OPT_DEREF, &deref );
 306         }
 307
 308         /* chase referrals */
 309         if( ldap_set_option( ld, LDAP_OPT_REFERRALS,
 310                 referrals ? LDAP_OPT_ON : LDAP_OPT_OFF ) != LDAP_OPT_SUCCESS )
 311         {
 312                 fprintf( stderr, "Could not set LDAP_OPT_REFERRALS %s\n",
 313                         referrals ? "on" : "off" );
 314                 return EXIT_FAILURE;
 315         }
 316
 317         if (version == -1 ) {
 318                 version = 3;
 319         }
 320
 321         if( ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version )
 322                 != LDAP_OPT_SUCCESS )
 323         {
 324                 fprintf( stderr, "Could not set LDAP_OPT_PROTOCOL_VERSION %d\n",
 325                         version );
 326                 return EXIT_FAILURE;
 327         }
 328
 329         if ( use_tls && ldap_start_tls_s( ld, NULL, NULL ) != LDAP_SUCCESS ) {
 330                 if ( use_tls > 1 ) {
 331                         ldap_perror( ld, "ldap_start_tls" );
 332                         return EXIT_FAILURE;
 333                 }
 334                 fprintf( stderr, "WARNING: could not start TLS\n" );
 335         }
 336
 337         if (want_bindpw) {
 338                 passwd.bv_val = getpassphrase("Enter LDAP Password: ");
 339                 passwd.bv_len = passwd.bv_val ? strlen( passwd.bv_val ) : 0;
 340         }
 341
 342         if ( authmethod == LDAP_AUTH_SASL ) {
 343 #ifdef HAVE_CYRUS_SASL
 344                 int     minssf = 0, maxssf = 0;
 345
 346                 if ( sasl_integrity > 0 )
 347                         maxssf = 1;
 348                 if ( sasl_integrity > 1 )
 349                         minssf = 1;
 350                 if ( sasl_privacy > 0 )
 351                         maxssf = 100000; /* Something big value */
 352                 if ( sasl_privacy > 1 )
 353                         minssf = 56;
 354
 355                 if ( ldap_set_option( ld, LDAP_OPT_X_SASL_MINSSF,
 356                                 (void *)&minssf ) != LDAP_OPT_SUCCESS ) {
 357                         fprintf( stderr, "Could not set LDAP_OPT_X_SASL_MINSSF"
 358                                 "%d\n", minssf);
 359                         return( EXIT_FAILURE );
 360                 }
 361                 if ( ldap_set_option( ld, LDAP_OPT_X_SASL_MAXSSF,
 362                                 (void *)&maxssf ) != LDAP_OPT_SUCCESS ) {
 363                         fprintf( stderr, "Could not set LDAP_OPT_X_SASL_MAXSSF"
 364                                 "%d\n", maxssf);
 365                         return( EXIT_FAILURE );
 366                 }
 367
 368                 rc = ldap_negotiated_sasl_bind_s( ld, binddn, sasl_authc_id,
 369                                 sasl_authz_id, sasl_mech,
 370                                 passwd.bv_len ? &passwd : NULL,
 371                                 NULL, NULL );
 372
 373                 if( rc != LDAP_SUCCESS ) {
 374                         ldap_perror( ld, "ldap_negotiated_sasl_bind_s" );
 375                         return( EXIT_FAILURE );
 376                 }
 377 #else
 378                 fprintf( stderr, "%s was not compiled with SASL support\n",
 379                         argv[0] );
 380                 return( EXIT_FAILURE );
 381 #endif
 382         }
 383         else {
 384                 if ( ldap_bind_s( ld, binddn, passwd.bv_val, authmethod )
 385                                 != LDAP_SUCCESS ) {
 386                         ldap_perror( ld, "ldap_bind" );
 387                         return( EXIT_FAILURE );
 388                 }
 389         }
 390
 391         if ( manageDSAit ) {
 392                 int err;
 393                 LDAPControl c;
 394                 LDAPControl *ctrls[2];
 395                 ctrls[0] = &c;
 396                 ctrls[1] = NULL;
 397
 398                 c.ldctl_oid = LDAP_CONTROL_MANAGEDSAIT;
 399                 c.ldctl_value.bv_val = NULL;
 400                 c.ldctl_value.bv_len = 0;
 401                 c.ldctl_iscritical = manageDSAit > 1;
 402
 403                 err = ldap_set_option( ld, LDAP_OPT_SERVER_CONTROLS, &ctrls );
 404
 405                 if( err != LDAP_OPT_SUCCESS ) {
 406                         fprintf( stderr, "Could not set ManageDSAit %scontrol\n",
 407                                 c.ldctl_iscritical ? "critical " : "" );
 408                         if( c.ldctl_iscritical ) {
 409                                 exit( EXIT_FAILURE );
 410                         }
 411                 }
 412         }
 413
 414         rc = 0;
 415     if ( fp == NULL ) {
 416         for ( ; optind < argc; ++optind ) {
 417             rc = dodelete( ld, argv[ optind ] );
 418         }
 419     } else {
 420         while ((rc == 0 || contoper) && fgets(buf, sizeof(buf), fp) != NULL) {
 421             buf[ strlen( buf ) - 1 ] = '\0';    /* remove trailing newline */
 422             if ( *buf != '\0' ) {
 423                 rc = dodelete( ld, buf );
 424             }
 425         }
 426     }
 427
 428     ldap_unbind( ld );
 429
 430         return( rc );
 431 }
 432
 433
 434 static int dodelete(
 435     LDAP        *ld,
 436     const char  *dn)
 437 {
 438         int id;
 439         int     rc, code;
 440         char *matcheddn = NULL, *text = NULL, **refs = NULL;
 441         LDAPMessage *res;
 442
 443         if ( verbose ) {
 444                 printf( "%sdeleting entry \"%s\"\n",
 445                         (not ? "!" : ""), dn );
 446         }
 447
 448         if ( not ) {
 449                 return LDAP_SUCCESS;
 450         }
 451
 452         /* If prune is on, remove a whole subtree.  Delete the children of the
 453          * DN recursively, then the DN requested.
 454          */
 455         if ( prune ) deletechildren( ld, dn );
 456
 457         rc = ldap_delete_ext( ld, dn, NULL, NULL, &id );
 458         if ( rc != LDAP_SUCCESS ) {
 459                 fprintf( stderr, "ldapdelete: ldap_delete_ext: %s (%d)\n",
 460                         ldap_err2string( rc ), rc );
 461                 return rc;
 462         }
 463
 464         rc = ldap_result( ld, LDAP_RES_ANY, LDAP_MSG_ALL, NULL, &res );
 465         if ( rc != LDAP_SUCCESS ) {
 466                 fprintf( stderr, "ldapdelete: ldap_result: %s (%d)\n",
 467                         ldap_err2string( rc ), rc );
 468                 return rc;
 469         }
 470
 471         rc = ldap_parse_result( ld, res, &code, &matcheddn, &text, &refs, NULL, 1 );
 472
 473         if( rc != LDAP_SUCCESS ) {
 474                 fprintf( stderr, "ldapdelete: ldap_parse_result: %s (%d)\n",
 475                         ldap_err2string( rc ), rc );
 476                 return rc;
 477         }
 478
 479         if( verbose || code != LDAP_SUCCESS ||
 480                 (matcheddn && *matcheddn) || (text && *text) || (refs && *refs) )
 481         {
 482                 printf( "Delete Result: %s (%d)\n", ldap_err2string( code ), code );
 483
 484                 if( text && *text ) {
 485                         printf( "Additional info: %s\n", text );
 486                 }
 487
 488                 if( matcheddn && *matcheddn ) {
 489                         printf( "Matched DN: %s\n", matcheddn );
 490                 }
 491
 492                 if( refs ) {
 493                         int i;
 494                         for( i=0; refs[i]; i++ ) {
 495                                 printf("Referral: %s\n", refs[i] );
 496                         }
 497                 }
 498         }
 499
 500         ber_memfree( text );
 501         ber_memfree( matcheddn );
 502         ber_memvfree( (void **) refs );
 503
 504         return code;
 505 }
 506
 507 /*
 508  * Delete all the children of an entry recursively until leaf nodes are reached.
 509  *
 510  */
 511 static int deletechildren(
 512         LDAP *ld,
 513         const char *dn )
 514 {
 515         LDAPMessage *res, *e;
 516         int entries;
 517         int rc;
 518         static char *attrs[] = { "1.1", NULL };
 519
 520         if ( verbose ) printf ( "deleting children of: %s\n", dn );
 521         /*
 522          * Do a one level search at dn for children.  For each, delete its children.
 523          */
 524
 525         rc = ldap_search_ext_s( ld, dn, LDAP_SCOPE_ONELEVEL, NULL, attrs, 1,
 526                 NULL, NULL, NULL, -1, &res );
 527         if ( rc != LDAP_SUCCESS ) {
 528                 ldap_perror( ld, "ldap_search" );
 529                 return( rc );
 530         }
 531
 532         entries = ldap_count_entries( ld, res );
 533
 534         if ( entries > 0 ) {
 535                 int i;
 536
 537                 for (e = ldap_first_entry( ld, res ), i = 0; e != NULL;
 538                         e = ldap_next_entry( ld, e ), i++ )
 539                 {
 540                         char *dn = ldap_get_dn( ld, e );
 541
 542                         if( dn == NULL ) {
 543                                 ldap_perror( ld, "ldap_prune" );
 544                                 ldap_get_option( ld, LDAP_OPT_ERROR_NUMBER, &rc );
 545                                 ber_memfree( dn );
 546                                 return rc;
 547                         }
 548
 549                         rc = deletechildren( ld, dn );
 550                         if ( rc == -1 ) {
 551                                 ldap_perror( ld, "ldap_prune" );
 552                                 ber_memfree( dn );
 553                                 return rc;
 554                         }
 555
 556                         if ( verbose ) {
 557                                 printf( "\tremoving %s\n", dn );
 558                         }
 559
 560                         rc = ldap_delete_s( ld, dn );
 561                         if ( rc == -1 ) {
 562                                 ldap_perror( ld, "ldap_delete" );
 563                                 ber_memfree( dn );
 564                                 return rc;
 565
 566                         }
 567
 568                         if ( verbose ) {
 569                                 printf( "\t%s removed\n", dn );
 570                         }
 571
 572                         ber_memfree( dn );
 573                 }
 574         }
 575
 576         ldap_msgfree( res );
 577         return rc;
 578 }