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