1 /*
2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
3 */
4
5 #include <stdio.h>
6 #include <ctype.h>
7 #include <string.h>
8 #include <sys/types.h>
9 #include <sys/socket.h>
10 #include <sys/time.h>
11 #include <sys/stat.h>
12 #include <sys/file.h>
13 #include <fcntl.h>
14 #include <unistd.h>
15
16 #include "lber.h"
17 #include "ldap.h"
18
19 #define MOD_USE_BVALS
20
21 #ifdef NEEDPROTOS
22 static void handle_result( LDAP *ld, LDAPMessage *lm );
23 static void print_ldap_result( LDAP *ld, LDAPMessage *lm, char *s );
24 static void print_search_entry( LDAP *ld, LDAPMessage *res );
25 static void free_list( char **list );
26 #else
27 static void handle_result();
28 static void print_ldap_result();
29 static void print_search_entry();
30 static void free_list();
31 #endif /* NEEDPROTOS */
32
33 #define NOCACHEERRMSG "don't compile with -DNO_CACHE if you desire local caching"
34
35 char *dnsuffix;
36
37 static char *
getaline(char * line,int len,FILE * fp,char * prompt)38 getaline( char *line, int len, FILE *fp, char *prompt )
39 {
40 printf(prompt);
41
42 if ( fgets( line, len, fp ) == NULL )
43 return( NULL );
44
45 line[ strlen( line ) - 1 ] = '\0';
46
47 return( line );
48 }
49
50 static char **
get_list(char * prompt)51 get_list( char *prompt )
52 {
53 static char buf[256];
54 int num;
55 char **result;
56
57 num = 0;
58 result = (char **) 0;
59 while ( 1 ) {
60 getaline( buf, sizeof(buf), stdin, prompt );
61
62 if ( *buf == '\0' )
63 break;
64
65 if ( result == (char **) 0 )
66 result = (char **) malloc( sizeof(char *) );
67 else
68 result = (char **) realloc( result,
69 sizeof(char *) * (num + 1) );
70
71 result[num++] = (char *) strdup( buf );
72 }
73 if ( result == (char **) 0 )
74 return( NULL );
75 result = (char **) realloc( result, sizeof(char *) * (num + 1) );
76 result[num] = NULL;
77
78 return( result );
79 }
80
81
82 static void
free_list(char ** list)83 free_list( char **list )
84 {
85 int i;
86
87 if ( list != NULL ) {
88 for ( i = 0; list[ i ] != NULL; ++i ) {
89 free( list[ i ] );
90 }
91 free( (char *)list );
92 }
93 }
94
95
96 #ifdef MOD_USE_BVALS
97 static int
file_read(char * path,struct berval * bv)98 file_read( char *path, struct berval *bv )
99 {
100 FILE *fp;
101 long rlen;
102 int eof;
103
104 if (( fp = fopen( path, "r" )) == NULL ) {
105 perror( path );
106 return( -1 );
107 }
108
109 if ( fseek( fp, 0L, SEEK_END ) != 0 ) {
110 perror( path );
111 fclose( fp );
112 return( -1 );
113 }
114
115 bv->bv_len = ftell( fp );
116
117 if (( bv->bv_val = (char *)malloc( bv->bv_len )) == NULL ) {
118 perror( "malloc" );
119 fclose( fp );
120 return( -1 );
121 }
122
123 if ( fseek( fp, 0L, SEEK_SET ) != 0 ) {
124 perror( path );
125 fclose( fp );
126 return( -1 );
127 }
128
129 rlen = fread( bv->bv_val, 1, bv->bv_len, fp );
130 eof = feof( fp );
131 fclose( fp );
132
133 if ( rlen != bv->bv_len ) {
134 perror( path );
135 free( bv->bv_val );
136 return( -1 );
137 }
138
139 return( bv->bv_len );
140 }
141 #endif /* MOD_USE_BVALS */
142
143
144 static LDAPMod **
get_modlist(char * prompt1,char * prompt2,char * prompt3)145 get_modlist( char *prompt1, char *prompt2, char *prompt3 )
146 {
147 static char buf[256];
148 int num;
149 LDAPMod tmp;
150 LDAPMod **result;
151 #ifdef MOD_USE_BVALS
152 struct berval **bvals;
153 #endif /* MOD_USE_BVALS */
154
155 num = 0;
156 result = NULL;
157 while ( 1 ) {
158 if ( prompt1 ) {
159 getaline( buf, sizeof(buf), stdin, prompt1 );
160 tmp.mod_op = atoi( buf );
161
162 if ( tmp.mod_op == -1 || buf[0] == '\0' )
163 break;
164 }
165
166 getaline( buf, sizeof(buf), stdin, prompt2 );
167 if ( buf[0] == '\0' )
168 break;
169 tmp.mod_type = strdup( buf );
170
171 tmp.mod_values = get_list( prompt3 );
172 #ifdef MOD_USE_BVALS
173 if ( tmp.mod_values != NULL ) {
174 int i;
175
176 for ( i = 0; tmp.mod_values[i] != NULL; ++i )
177 ;
178 bvals = (struct berval **)calloc( i + 1,
179 sizeof( struct berval *));
180 for ( i = 0; tmp.mod_values[i] != NULL; ++i ) {
181 bvals[i] = (struct berval *)malloc(
182 sizeof( struct berval ));
183 if ( strncmp( tmp.mod_values[i], "{FILE}",
184 6 ) == 0 ) {
185 if ( file_read( tmp.mod_values[i] + 6,
186 bvals[i] ) < 0 ) {
187 return( NULL );
188 }
189 } else {
190 bvals[i]->bv_val = tmp.mod_values[i];
191 bvals[i]->bv_len =
192 strlen( tmp.mod_values[i] );
193 }
194 }
195 tmp.mod_bvalues = bvals;
196 tmp.mod_op |= LDAP_MOD_BVALUES;
197 }
198 #endif /* MOD_USE_BVALS */
199
200 if ( result == NULL )
201 result = (LDAPMod **) malloc( sizeof(LDAPMod *) );
202 else
203 result = (LDAPMod **) realloc( result,
204 sizeof(LDAPMod *) * (num + 1) );
205
206 result[num] = (LDAPMod *) malloc( sizeof(LDAPMod) );
207 *(result[num]) = tmp; /* struct copy */
208 num++;
209 }
210 if ( result == NULL )
211 return( NULL );
212 result = (LDAPMod **) realloc( result, sizeof(LDAPMod *) * (num + 1) );
213 result[num] = NULL;
214
215 return( result );
216 }
217
218
219 int
bind_prompt(LDAP * ld,char ** dnp,char ** passwdp,int * authmethodp,int freeit)220 bind_prompt( LDAP *ld, char **dnp, char **passwdp, int *authmethodp,
221 int freeit )
222 {
223 static char dn[256], passwd[256];
224
225 if ( !freeit ) {
226 #ifdef KERBEROS
227 getaline( dn, sizeof(dn), stdin,
228 "re-bind method (0->simple, 1->krbv41, 2->krbv42, 3->krbv41&2)? " );
229 if (( *authmethodp = atoi( dn )) == 3 ) {
230 *authmethodp = LDAP_AUTH_KRBV4;
231 } else {
232 *authmethodp |= 0x80;
233 }
234 #else /* KERBEROS */
235 *authmethodp = LDAP_AUTH_SIMPLE;
236 #endif /* KERBEROS */
237
238 getaline( dn, sizeof(dn), stdin, "re-bind dn? " );
239 strcat( dn, dnsuffix );
240 *dnp = dn;
241
242 if ( *authmethodp == LDAP_AUTH_SIMPLE && dn[0] != '\0' ) {
243 getaline( passwd, sizeof(passwd), stdin,
244 "re-bind password? " );
245 } else {
246 passwd[0] = '\0';
247 }
248 *passwdp = passwd;
249 }
250
251 return( LDAP_SUCCESS );
252 }
253
254
255 int
main(int argc,char ** argv)256 main(int argc, char **argv )
257 {
258 LDAP *ld;
259 int i, c, port, cldapflg, errflg, method, id,
260 msgtype, delrdn, theInt, sizelimit, err;
261 char line[256], command1, command2, command3;
262 char passwd[64], dn[256], rdn[64], attr[64], value[256];
263 char filter[256], *host, **types;
264 char *mechanism;
265
266 char **exdn;
267 char *usage = "usage: %s [-u] [-h host] [-d level] [-s dnsuffix] [-p port] [-t file] [-T file]\n";
268 int bound, all, scope, attrsonly;
269 LDAPMessage *res;
270 LDAPMod **mods, **attrs;
271 struct timeval timeout, timelimit;
272 char *copyfname = NULL;
273 int copyoptions = 0, resultusetimelimit = 0;
274 LDAPURLDesc *ludp;
275 struct berval bv, cred, *srvcrds = NULL;
276 extern char *optarg;
277 extern int optind;
278 LDAPControl *ctrls[2];
279 LDAPControl aCtrl;
280
281
282 #ifdef MACOS
283 if (( argv = get_list( "cmd line arg?" )) == NULL ) {
284 exit( 1 );
285 }
286 for ( argc = 0; argv[ argc ] != NULL; ++argc ) {
287 ;
288 }
289 #endif /* MACOS */
290
291 host = NULL;
292 port = LDAP_PORT;
293 dnsuffix = "";
294 cldapflg = errflg = 0;
295 ctrls[0] = &aCtrl;
296 ctrls[1] = NULL;
297
298 while (( c = getopt( argc, argv, "uh:d:s:p:t:T:" )) != -1 ) {
299 switch( c ) {
300 case 'u':
301 #ifdef CLDAP
302 cldapflg++;
303 #else /* CLDAP */
304 printf( "Compile with -DCLDAP for UDP support\n" );
305 #endif /* CLDAP */
306 break;
307
308 case 'd':
309 #ifdef LDAP_DEBUG
310 ldap_debug = atoi( optarg );
311 if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
312 lber_debug = ldap_debug;
313 }
314 #else
315 printf( "Compile with -DLDAP_DEBUG for debugging\n" );
316 #endif
317 break;
318
319 case 'h':
320 host = optarg;
321 break;
322
323 case 's':
324 dnsuffix = optarg;
325 break;
326
327 case 'p':
328 port = atoi( optarg );
329 break;
330
331 #if !defined(MACOS) && !defined(DOS)
332 case 't': /* copy ber's to given file */
333 copyfname = strdup( optarg );
334 copyoptions = LBER_TO_FILE;
335 break;
336
337 case 'T': /* only output ber's to given file */
338 copyfname = strdup( optarg );
339 copyoptions = (LBER_TO_FILE | LBER_TO_FILE_ONLY);
340 break;
341 #endif
342
343 default:
344 ++errflg;
345 }
346 }
347
348 if ( host == NULL && optind == argc - 1 ) {
349 host = argv[ optind ];
350 ++optind;
351 }
352
353 if ( errflg || optind < argc - 1 ) {
354 fprintf( stderr, usage, argv[ 0 ] );
355 exit( 1 );
356 }
357
358 printf( "%s( %s, %d )\n", cldapflg ? "cldap_open" : "ldap_init",
359 host == NULL ? "(null)" : host, port );
360
361 if ( cldapflg ) {
362 #ifdef CLDAP
363 ld = cldap_open( host, port );
364 #endif /* CLDAP */
365 } else {
366 ld = ldap_init( host, port );
367 }
368
369 if ( ld == NULL ) {
370 perror( "ldap_init" );
371 exit(1);
372 }
373
374 #if !defined(MACOS) && !defined(DOS)
375 if ( copyfname != NULL ) {
376 if ( (ld->ld_sb.sb_fd = open( copyfname, O_WRONLY | O_CREAT,
377 0600 )) == -1 ) {
378 perror( copyfname );
379 exit ( 1 );
380 }
381 ld->ld_sb.sb_options = copyoptions;
382 }
383 #endif
384
385 bound = 0;
386 timeout.tv_sec = 0;
387 timeout.tv_usec = 0;
388 timelimit.tv_sec = 0;
389 timelimit.tv_usec = 0;
390
391 (void) memset( line, '\0', sizeof(line) );
392 while ( getaline( line, sizeof(line), stdin, "\ncommand? " ) != NULL ) {
393 command1 = line[0];
394 command2 = line[1];
395 command3 = line[2];
396
397 switch ( command1 ) {
398 case 'a': /* add or abandon */
399 switch ( command2 ) {
400 case 'd': /* add */
401 getaline( dn, sizeof(dn), stdin, "dn? " );
402 strcat( dn, dnsuffix );
403 if ( (attrs = get_modlist( NULL, "attr? ",
404 "value? " )) == NULL )
405 break;
406 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
407 if ((err = ldap_add_ext( ld, dn, attrs, NULL, NULL, &id )) != LDAP_SUCCESS )
408 printf( "Error in ldap_add_ext: %s\n", ldap_err2string(err) );
409 else
410 printf( "Add initiated with id %d\n", id );
411 }
412 else {
413 if ( (id = ldap_add( ld, dn, attrs )) == -1 )
414 ldap_perror( ld, "ldap_add" );
415 else
416 printf( "Add initiated with id %d\n", id );
417 }
418
419 break;
420
421 case 'b': /* abandon */
422 getaline( line, sizeof(line), stdin, "msgid? " );
423 id = atoi( line );
424 if ( ldap_abandon( ld, id ) != 0 )
425 ldap_perror( ld, "ldap_abandon" );
426 else
427 printf( "Abandon successful\n" );
428 break;
429 default:
430 printf( "Possibilities: [ad]d, [ab]ort\n" );
431 }
432 break;
433
434 case 'b': /* asynch bind */
435 #ifdef KERBEROS
436 getaline( line, sizeof(line), stdin,
437 "method (0->simple, 1->krbv41, 2->krbv42)? " );
438 method = atoi( line ) | 0x80;
439 #else /* KERBEROS */
440 method = LDAP_AUTH_SIMPLE;
441 #endif /* KERBEROS */
442 getaline( dn, sizeof(dn), stdin, "dn? " );
443 strcat( dn, dnsuffix );
444
445 if ( method == LDAP_AUTH_SIMPLE && dn[0] != '\0' )
446 getaline( passwd, sizeof(passwd), stdin,
447 "password? " );
448 else
449 passwd[0] = '\0';
450
451 if ( ldap_bind( ld, dn, passwd, method ) == -1 ) {
452 fprintf( stderr, "ldap_bind failed\n" );
453 ldap_perror( ld, "ldap_bind" );
454 } else {
455 printf( "Bind initiated\n" );
456 bound = 1;
457 }
458 break;
459
460 case 'B': /* synch bind */
461 #ifdef KERBEROS
462 getaline( line, sizeof(line), stdin,
463 "method 0->simple 1->krbv41 2->krbv42 3->krb? " );
464 method = atoi( line );
465 if ( method == 3 )
466 method = LDAP_AUTH_KRBV4;
467 else
468 method = method | 0x80;
469 #else /* KERBEROS */
470 getaline( line, sizeof(line), stdin,
471 "method 0->simple, 1->SASL? ");
472 method = atoi (line);
473 if (method == 1){
474 method = LDAP_AUTH_SASL;
475 getaline( line, sizeof(line), stdin,
476 "mechanism 0->CRAM_MD5, 1->TLS? ");
477 theInt = atoi(line);
478 if (theInt == 0){
479 mechanism = LDAP_SASL_CRAM_MD5;
480 }
481 else{
482 mechanism = LDAP_SASL_X511_STRONG;
483 }
484 } else {
485 method = LDAP_AUTH_SIMPLE;
486 }
487
488 #endif /* KERBEROS */
489 getaline( dn, sizeof(dn), stdin, "dn? " );
490 strcat( dn, dnsuffix );
491
492 if ( dn[0] != '\0' )
493 getaline( passwd, sizeof(passwd), stdin,
494 "password? " );
495 else
496 passwd[0] = '\0';
497
498 if (method == LDAP_AUTH_SIMPLE) {
499 if ( ldap_bind_s( ld, dn, passwd, method ) !=
500 LDAP_SUCCESS ) {
501 fprintf( stderr, "ldap_bind_s failed\n" );
502 ldap_perror( ld, "ldap_bind_s" );
503 } else {
504 printf( "Bind successful\n" );
505 bound = 1;
506 }
507 } else {
508 if (strcmp(mechanism, LDAP_SASL_CRAM_MD5) == 0){
509 cred.bv_val = passwd;
510 cred.bv_len = strlen(passwd);
511
512 if ( ldap_sasl_cram_md5_bind_s(ld, dn, &cred, NULL, NULL) != LDAP_SUCCESS ){
513 fprintf( stderr, "ldap_sasl_cram_md5_bind_s failed\n" );
514 ldap_perror( ld, "ldap_sasl_cram_md5_bind_s" );
515 } else {
516 printf ( "Bind successful\n");
517 bound = 1;
518 }
519 } else {
520 if (ldap_sasl_bind_s(ld, dn, mechanism, &cred, NULL, NULL, &srvcrds ) != LDAP_SUCCESS){
521 fprintf( stderr, "ldap_sasl_bind_s failed\n" );
522 ldap_perror( ld, "ldap_sasl_bind_s" );
523 }
524 }
525 }
526 break;
527
528 case 'c': /* compare */
529 getaline( dn, sizeof(dn), stdin, "dn? " );
530 strcat( dn, dnsuffix );
531 getaline( attr, sizeof(attr), stdin, "attr? " );
532 getaline( value, sizeof(value), stdin, "value? " );
533
534 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
535 bv.bv_val = value;
536 bv.bv_len = strlen(value);
537 if ((err = ldap_compare_ext( ld, dn, attr, &bv, NULL, NULL, &id )) != LDAP_SUCCESS )
538 printf( "Error in ldap_compare_ext: %s\n", ldap_err2string(err) );
539 else
540 printf( "Compare initiated with id %d\n", id );
541 } else {
542 if ( (id = ldap_compare( ld, dn, attr, value )) == -1 )
543 ldap_perror( ld, "ldap_compare" );
544 else
545 printf( "Compare initiated with id %d\n", id );
546 }
547 break;
548
549 case 'd': /* turn on debugging */
550 #ifdef LDAP_DEBUG
551 getaline( line, sizeof(line), stdin, "debug level? " );
552 ldap_debug = atoi( line );
553 if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
554 lber_debug = ldap_debug;
555 }
556 #else
557 printf( "Compile with -DLDAP_DEBUG for debugging\n" );
558 #endif
559 break;
560
561 case 'E': /* explode a dn */
562 getaline( line, sizeof(line), stdin, "dn? " );
563 exdn = ldap_explode_dn( line, 0 );
564 for ( i = 0; exdn != NULL && exdn[i] != NULL; i++ ) {
565 printf( "\t%s\n", exdn[i] );
566 }
567 break;
568
569 case 'g': /* set next msgid */
570 getaline( line, sizeof(line), stdin, "msgid? " );
571 ld->ld_msgid = atoi( line );
572 break;
573
574 case 'v': /* set version number */
575 getaline( line, sizeof(line), stdin, "version? " );
576 theInt = atoi(line);
577 ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &theInt);
578 break;
579
580 case 'm': /* modify or modifyrdn */
581 if ( strncmp( line, "modify", 4 ) == 0 ) {
582 getaline( dn, sizeof(dn), stdin, "dn? " );
583 strcat( dn, dnsuffix );
584 if ( (mods = get_modlist(
585 "mod (0=>add, 1=>delete, 2=>replace -1=>done)? ",
586 "attribute type? ", "attribute value? " ))
587 == NULL )
588 break;
589 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
590 if ((err = ldap_modify_ext( ld, dn, mods, NULL, NULL, &id )) != LDAP_SUCCESS )
591 printf( "Error in ldap_modify_ext: %s\n", ldap_err2string(err) );
592 else
593 printf( "Modify initiated with id %d\n", id );
594 }
595 else {
596 if ( (id = ldap_modify( ld, dn, mods )) == -1 )
597 ldap_perror( ld, "ldap_modify" );
598 else
599 printf( "Modify initiated with id %d\n", id );
600 }
601 } else if ( strncmp( line, "modrdn", 4 ) == 0 ) {
602 getaline( dn, sizeof(dn), stdin, "dn? " );
603 strcat( dn, dnsuffix );
604 getaline( rdn, sizeof(rdn), stdin, "newrdn? " );
605 getaline( line, sizeof(line), stdin, "delete old rdn (0=>no, 1=>yes)?");
606 delrdn = atoi(line);
607 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
608 if ((err = ldap_rename(ld, dn, rdn, NULL, delrdn, NULL,NULL, &id)) != LDAP_SUCCESS){
609 printf( "Error in ldap_rename (modrdn): %s\n", ldap_err2string(err));
610 }
611 else
612 printf( "Modrdn initiated with id %d\n", id );
613 }
614 else {
615 if ( (id = ldap_modrdn( ld, dn, rdn, delrdn )) == -1 )
616 ldap_perror( ld, "ldap_modrdn" );
617 else
618 printf( "Modrdn initiated with id %d\n", id );
619 }
620 } else {
621 printf( "Possibilities: [modi]fy, [modr]dn\n" );
622 }
623 break;
624
625 case 'q': /* quit */
626 #ifdef CLDAP
627 if ( cldapflg )
628 cldap_close( ld );
629 #endif /* CLDAP */
630 if ( !cldapflg )
631 ldap_unbind( ld );
632 exit( 0 );
633 break;
634
635 case 'r': /* result or remove */
636 switch ( command3 ) {
637 case 's': /* result */
638 getaline( line, sizeof(line), stdin,
639 "msgid (-1=>any)? " );
640 if ( line[0] == '\0' )
641 id = -1;
642 else
643 id = atoi( line );
644 getaline( line, sizeof(line), stdin,
645 "all (0=>any, 1=>all)? " );
646 if ( line[0] == '\0' )
647 all = 1;
648 else
649 all = atoi( line );
650
651 if (( msgtype = ldap_result( ld, id, all,
652 resultusetimelimit ? &timelimit : &timeout, &res )) < 1 ) {
653 ldap_perror( ld, "ldap_result" );
654 break;
655 }
656 printf( "\nresult: msgtype %d msgid %d\n",
657 msgtype, res->lm_msgid );
658 handle_result( ld, res );
659 if (all || msgtype == LDAP_RES_SEARCH_RESULT)
660 resultusetimelimit = 0;
661 res = NULLMSG;
662 break;
663
664 case 'm': /* remove */
665 getaline( dn, sizeof(dn), stdin, "dn? " );
666 strcat( dn, dnsuffix );
667 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
668 if ((err = ldap_delete_ext( ld, dn, NULL, NULL, &id )) != LDAP_SUCCESS )
669 printf( "Error in ldap_delete_ext: %s\n", ldap_err2string(err) );
670 else
671 printf( "Remove initiated with id %d\n", id );
672 } else {
673 if ( (id = ldap_delete( ld, dn )) == -1 )
674 ldap_perror( ld, "ldap_delete" );
675 else
676 printf( "Remove initiated with id %d\n", id );
677 }
678 break;
679
680 default:
681 printf( "Possibilities: [rem]ove, [res]ult\n" );
682 break;
683 }
684 break;
685
686 case 's': /* search */
687 getaline( dn, sizeof(dn), stdin, "searchbase? " );
688 strcat( dn, dnsuffix );
689 getaline( line, sizeof(line), stdin,
690 "scope (0=Base, 1=One Level, 2=Subtree)? " );
691 scope = atoi( line );
692 getaline( filter, sizeof(filter), stdin,
693 "search filter (e.g. sn=jones)? " );
694 types = get_list( "attrs to return? " );
695 getaline( line, sizeof(line), stdin,
696 "attrsonly (0=attrs&values, 1=attrs only)? " );
697 attrsonly = atoi( line );
698
699 if ( cldapflg ) {
700 #ifdef CLDAP
701 getaline( line, sizeof(line), stdin,
702 "Requestor DN (for logging)? " );
703 if ( cldap_search_s( ld, dn, scope, filter, types,
704 attrsonly, &res, line ) != 0 ) {
705 ldap_perror( ld, "cldap_search_s" );
706 } else {
707 printf( "\nresult: msgid %d\n",
708 res->lm_msgid );
709 handle_result( ld, res );
710 res = NULLMSG;
711 }
712 #endif /* CLDAP */
713 } else {
714 theInt = 0;
715 if (ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &i) == LDAP_SUCCESS && i == LDAP_VERSION3){
716 resultusetimelimit = 1;
717 getaline( line, sizeof(line), stdin,
718 "ldap_search_ext (0=>no, 1=>yes - default: yes)? " );
719 if (line[0] == '\0')
720 theInt = 1;
721 else
722 theInt = atoi( line );
723 }
724 if (theInt){
725 getaline(line, sizeof(line), stdin, "time limit?");
726 timelimit.tv_sec = atoi(line);
727 resultusetimelimit = 1;
728 getaline(line, sizeof(line), stdin, "size limit?");
729 sizelimit = atoi(line);
730 if (( err = ldap_search_ext(ld, dn, scope, filter, types, attrsonly, NULL, NULL,
731 &timelimit, sizelimit, &id)) != LDAP_SUCCESS){
732 printf( "Error in ldap_search_ext: %s\n", ldap_err2string(err));
733 } else {
734 printf( "Search initiated with id %d\n", id );
735 }
736 } else {
737 if (( id = ldap_search( ld, dn, scope, filter,
738 types, attrsonly )) == -1 ) {
739 ldap_perror( ld, "ldap_search" );
740 } else {
741 printf( "Search initiated with id %d\n", id );
742 }
743 }
744 }
745 free_list( types );
746 break;
747
748 case 't': /* set timeout value */
749 getaline( line, sizeof(line), stdin, "timeout? " );
750 timeout.tv_sec = atoi( line );
751 break;
752
753 case 'U': /* set ufn search prefix */
754 getaline( line, sizeof(line), stdin, "ufn prefix? " );
755 ldap_ufn_setprefix( ld, line );
756 break;
757
758 case 'u': /* user friendly search w/optional timeout */
759 getaline( dn, sizeof(dn), stdin, "ufn? " );
760 strcat( dn, dnsuffix );
761 types = get_list( "attrs to return? " );
762 getaline( line, sizeof(line), stdin,
763 "attrsonly (0=attrs&values, 1=attrs only)? " );
764 attrsonly = atoi( line );
765
766 if ( command2 == 't' ) {
767 id = ldap_ufn_search_c( ld, dn, types,
768 attrsonly, &res, ldap_ufn_timeout,
769 &timeout );
770 } else {
771 id = ldap_ufn_search_s( ld, dn, types,
772 attrsonly, &res );
773 }
774 if ( res == NULL )
775 ldap_perror( ld, "ldap_ufn_search" );
776 else {
777 printf( "\nresult: err %d\n", id );
778 handle_result( ld, res );
779 res = NULLMSG;
780 }
781 free_list( types );
782 break;
783
784 case 'l': /* URL search */
785 getaline( line, sizeof(line), stdin,
786 "attrsonly (0=attrs&values, 1=attrs only)? " );
787 attrsonly = atoi( line );
788 getaline( line, sizeof(line), stdin, "LDAP URL? " );
789 if (( id = ldap_url_search( ld, line, attrsonly ))
790 == -1 ) {
791 ldap_perror( ld, "ldap_url_search" );
792 } else {
793 printf( "URL search initiated with id %d\n", id );
794 }
795 break;
796
797 case 'p': /* parse LDAP URL */
798 getaline( line, sizeof(line), stdin, "LDAP URL? " );
799 if (( i = ldap_url_parse( line, &ludp )) != 0 ) {
800 fprintf( stderr, "ldap_url_parse: error %d\n", i );
801 } else {
802 printf( "\t host: " );
803 if ( ludp->lud_host == NULL ) {
804 printf( "DEFAULT\n" );
805 } else {
806 printf( "<%s>\n", ludp->lud_host );
807 }
808 printf( "\t port: " );
809 if ( ludp->lud_port == 0 ) {
810 printf( "DEFAULT\n" );
811 } else {
812 printf( "%d\n", ludp->lud_port );
813 }
814 printf( "\t dn: <%s>\n", ludp->lud_dn );
815 printf( "\t attrs:" );
816 if ( ludp->lud_attrs == NULL ) {
817 printf( " ALL" );
818 } else {
819 for ( i = 0; ludp->lud_attrs[ i ] != NULL; ++i ) {
820 printf( " <%s>", ludp->lud_attrs[ i ] );
821 }
822 }
823 printf( "\n\t scope: %s\n", ludp->lud_scope == LDAP_SCOPE_UNKNOWN ? "DEFAULT (base)" :
824 ludp->lud_scope == LDAP_SCOPE_ONELEVEL ? "ONE" :
825 ludp->lud_scope == LDAP_SCOPE_BASE ? "BASE" :
826 ludp->lud_scope == LDAP_SCOPE_SUBTREE ? "SUB" : "**invalid**" );
827 printf( "\tfilter: <%s>\n", ludp->lud_filter ? ludp->lud_filter : "NONE");
828 if (ludp->lud_extensions){
829 printf("\textensions: \n");
830 for (i = 0; ludp->lud_extensions[i] != NULL; i++)
831 printf("\t\t%s (%s)\n", ludp->lud_extensions[i]->lue_type,
832 ludp->lud_extensions[i]->lue_iscritical ? "Critical" : "Non critical");
833 }
834
835 ldap_free_urldesc( ludp );
836 }
837 break;
838
839 case 'n': /* set dn suffix, for convenience */
840 getaline( line, sizeof(line), stdin, "DN suffix? " );
841 strcpy( dnsuffix, line );
842 break;
843
844 case 'e': /* enable cache */
845 #ifdef NO_CACHE
846 printf( NOCACHEERRMSG );
847 #else /* NO_CACHE */
848 getaline( line, sizeof(line), stdin, "Cache timeout (secs)? " );
849 i = atoi( line );
850 getaline( line, sizeof(line), stdin, "Maximum memory to use (bytes)? " );
851 if ( ldap_enable_cache( ld, i, atoi( line )) == 0 ) {
852 printf( "local cache is on\n" );
853 } else {
854 printf( "ldap_enable_cache failed\n" );
855 }
856 #endif /* NO_CACHE */
857 break;
858
859 case 'x': /* uncache entry */
860 #ifdef NO_CACHE
861 printf( NOCACHEERRMSG );
862 #else /* NO_CACHE */
863 getaline( line, sizeof(line), stdin, "DN? " );
864 ldap_uncache_entry( ld, line );
865 #endif /* NO_CACHE */
866 break;
867
868 case 'X': /* uncache request */
869 #ifdef NO_CACHE
870 printf( NOCACHEERRMSG );
871 #else /* NO_CACHE */
872 getaline( line, sizeof(line), stdin, "request msgid? " );
873 ldap_uncache_request( ld, atoi( line ));
874 #endif /* NO_CACHE */
875 break;
876
877 case 'o': /* set ldap options */
878 getaline( line, sizeof(line), stdin, "alias deref (0=never, 1=searching, 2=finding, 3=always)?" );
879 theInt = atoi(line);
880 ldap_set_option(ld, LDAP_OPT_DEREF, &theInt );
881 getaline( line, sizeof(line), stdin, "timelimit?" );
882 theInt = atoi(line);
883 ldap_set_option(ld, LDAP_OPT_TIMELIMIT, &theInt);
884 getaline( line, sizeof(line), stdin, "sizelimit?" );
885 theInt = atoi(line);
886 ldap_set_option(ld, LDAP_OPT_SIZELIMIT, &theInt);
887
888 ld->ld_options = 0;
889
890 #ifdef STR_TRANSLATION
891 getaline( line, sizeof(line), stdin,
892 "Automatic translation of T.61 strings (0=no, 1=yes)?" );
893 if ( atoi( line ) == 0 ) {
894 ld->ld_lberoptions &= ~LBER_TRANSLATE_STRINGS;
895 } else {
896 ld->ld_lberoptions |= LBER_TRANSLATE_STRINGS;
897 #ifdef LDAP_CHARSET_8859
898 getaline( line, sizeof(line), stdin,
899 "Translate to/from ISO-8859 (0=no, 1=yes?" );
900 if ( atoi( line ) != 0 ) {
901 ldap_set_string_translators( ld,
902 ldap_8859_to_t61,
903 ldap_t61_to_8859 );
904 }
905 #endif /* LDAP_CHARSET_8859 */
906 }
907 #endif /* STR_TRANSLATION */
908
909 #ifdef LDAP_DNS
910 getaline( line, sizeof(line), stdin,
911 "Use DN & DNS to determine where to send requests (0=no, 1=yes)?" );
912 if ( atoi( line ) != 0 ) {
913 ld->ld_options |= LDAP_OPT_DNS;
914 }
915 #endif /* LDAP_DNS */
916
917 getaline( line, sizeof(line), stdin,
918 "Recognize and chase referrals (0=no, 1=yes)?" );
919 if ( atoi( line ) != 0 ) {
920 theInt = LDAP_OPT_ON;
921 getaline( line, sizeof(line), stdin,
922 "Prompt for bind credentials when chasing referrals (0=no, 1=yes)?" );
923 if ( atoi( line ) != 0 ) {
924 ldap_set_option( ld, LDAP_OPT_REBIND_FN, bind_prompt );
925 }
926 } else {
927 theInt = LDAP_OPT_OFF;
928 }
929 ldap_set_option(ld, LDAP_OPT_REFERRALS, &theInt);
930 break;
931
932 case 'k': /* Set some controls */
933 getaline( line, sizeof(line), stdin,
934 "Set control: (0 for none, 1 for ManageDSA, 2 for preferredLang, 3 for BAD)?");
935 theInt = atoi(line);
936 switch (theInt){
937 case 0:
938 ldap_set_option(ld, LDAP_OPT_SERVER_CONTROLS, NULL);
939 break;
940 case 1:
941 aCtrl.ldctl_oid = "2.16.840.1.113730.3.4.2";
942 aCtrl.ldctl_iscritical = 1;
943 aCtrl.ldctl_value = NULL;
944 ldap_set_option(ld, LDAP_OPT_SERVER_CONTROLS, ctrls);
945 break;
946 case 2:
947 getaline( line, sizeof(line), stdin,
948 "Preferred Language Control : lang ?");
949 aCtrl.ldctl_oid = "1.3.6.1.4.1.1466.20035";
950 aCtrl.ldctl_iscritical = 1;
951 bv.bv_val = strdup(line);
952 bv.bv_len = strlen(line);
953 aCtrl.ldctl_value = &bv;
954 ldap_set_option(ld, LDAP_OPT_SERVER_CONTROLS, ctrls);
955 break;
956 default:
957 getaline( line, sizeof(line), stdin,
958 "Bad Control is critical (0=false, 1=true)?");
959 aCtrl.ldctl_oid = "1.1.1.1.1.1";
960 aCtrl.ldctl_iscritical = atoi(line);
961 aCtrl.ldctl_value = NULL;
962 ldap_set_option(ld, LDAP_OPT_SERVER_CONTROLS, ctrls);
963 break;
964 }
965 break;
966
967 case 'O': /* set cache options */
968 #ifdef NO_CACHE
969 printf( NOCACHEERRMSG );
970 #else /* NO_CACHE */
971 getaline( line, sizeof(line), stdin, "cache errors (0=smart, 1=never, 2=always)?" );
972 switch( atoi( line )) {
973 case 0:
974 ldap_set_cache_options( ld, 0 );
975 break;
976 case 1:
977 ldap_set_cache_options( ld,
978 LDAP_CACHE_OPT_CACHENOERRS );
979 break;
980 case 2:
981 ldap_set_cache_options( ld,
982 LDAP_CACHE_OPT_CACHEALLERRS );
983 break;
984 default:
985 printf( "not a valid cache option\n" );
986 }
987 #endif /* NO_CACHE */
988 break;
989
990 case '?': /* help */
991 printf( "Commands: [ad]d [ab]andon [b]ind\n" );
992 printf( " [B]ind async [c]ompare [l]URL search\n" );
993 printf( " [modi]fy [modr]dn [rem]ove\n" );
994 printf( " [res]ult [s]earch [q]uit/unbind\n\n" );
995 printf( " [u]fn search [ut]fn search with timeout\n" );
996 printf( " [d]ebug [e]nable cache set ms[g]id\n" );
997 printf( " d[n]suffix [t]imeout [v]ersion\n" );
998 printf( " [U]fn prefix [x]uncache entry [X]uncache request\n" );
999 printf( " [?]help [o]ptions [O]cache options\n" );
1000 printf( " [E]xplode dn [p]arse LDAP URL\n" );
1001 break;
1002
1003 default:
1004 printf( "Invalid command. Type ? for help.\n" );
1005 break;
1006 }
1007
1008 (void) memset( line, '\0', sizeof(line) );
1009 }
1010
1011 return( 0 );
1012 }
1013
1014 static void
handle_result(LDAP * ld,LDAPMessage * lm)1015 handle_result( LDAP *ld, LDAPMessage *lm )
1016 {
1017 switch ( lm->lm_msgtype ) {
1018 case LDAP_RES_COMPARE:
1019 printf( "Compare result\n" );
1020 print_ldap_result( ld, lm, "compare" );
1021 break;
1022
1023 case LDAP_RES_SEARCH_RESULT:
1024 printf( "Search result\n" );
1025 print_ldap_result( ld, lm, "search" );
1026 break;
1027
1028 case LDAP_RES_SEARCH_REFERENCE:
1029 printf( "Search reference\n" );
1030 print_search_entry( ld, lm );
1031 break;
1032
1033 case LDAP_RES_SEARCH_ENTRY:
1034 printf( "Search entry\n" );
1035 print_search_entry( ld, lm );
1036 break;
1037
1038 case LDAP_RES_ADD:
1039 printf( "Add result\n" );
1040 print_ldap_result( ld, lm, "add" );
1041 break;
1042
1043 case LDAP_RES_DELETE:
1044 printf( "Delete result\n" );
1045 print_ldap_result( ld, lm, "delete" );
1046 break;
1047
1048 case LDAP_RES_MODIFY:
1049 printf( "Modify result\n" );
1050 print_ldap_result( ld, lm, "modify" );
1051 break;
1052
1053 case LDAP_RES_MODRDN:
1054 printf( "ModRDN result\n" );
1055 print_ldap_result( ld, lm, "modrdn" );
1056 break;
1057
1058 case LDAP_RES_BIND:
1059 printf( "Bind result\n" );
1060 print_ldap_result( ld, lm, "bind" );
1061 break;
1062
1063 default:
1064 printf( "Unknown result type 0x%x\n", lm->lm_msgtype );
1065 print_ldap_result( ld, lm, "unknown" );
1066 }
1067 }
1068
1069 static void
print_ldap_result(LDAP * ld,LDAPMessage * lm,char * s)1070 print_ldap_result( LDAP *ld, LDAPMessage *lm, char *s )
1071 {
1072 int rc, i;
1073 int errCode;
1074 char *matched = NULL, *errMsg = NULL, **referrals = NULL;
1075 LDAPControl **srvctrls = NULL;
1076
1077 if ((rc = ldap_parse_result(ld, lm, &errCode, &matched, &errMsg, &referrals, &srvctrls, 0)) != LDAP_SUCCESS){
1078 fprintf(stderr, "%s: error while parsing result (%s)\n", s, ldap_err2string(rc));
1079 return;
1080 }
1081
1082
1083 fprintf(stderr, "%s: %s\n", s, ldap_err2string(errCode));
1084 if (errCode == LDAP_REFERRAL){
1085 fprintf(stderr, "\tReferrals returned: \n");
1086 for (i = 0; referrals[i] != NULL; i++)
1087 fprintf(stderr, "\t\t%s\n", referrals[i]);
1088 }
1089 if (errMsg && *errMsg)
1090 fprintf(stderr, "\tAdditional info: %s\n", errMsg);
1091 free(errMsg);
1092 if (NAME_ERROR(errCode) && matched && *matched){
1093 fprintf(stderr, "\tMatched DN: %s\n", matched);
1094 free(matched);
1095 }
1096 if (srvctrls != NULL){
1097 fprintf(stderr, "\tLDAPControls returned: \n");
1098 for (i=0;srvctrls[i] != NULL; i++)
1099 fprintf(stderr, "\t\t%s (%s)\n", srvctrls[i]->ldctl_oid, srvctrls[i]->ldctl_iscritical ? "Critical" : "Not critical");
1100 }
1101 return;
1102 }
1103
1104 static void
print_search_entry(LDAP * ld,LDAPMessage * res)1105 print_search_entry( LDAP *ld, LDAPMessage *res )
1106 {
1107 BerElement *ber;
1108 char *a, *dn, *ufn;
1109 struct berval **vals;
1110 int i;
1111 LDAPMessage *e;
1112
1113 for ( e = ldap_first_message( ld, res ); e != NULLMSG;
1114 e = ldap_next_message( ld, e ) ) {
1115 if ( e->lm_msgtype == LDAP_RES_SEARCH_RESULT )
1116 break;
1117
1118 dn = ldap_get_dn( ld, e );
1119 printf( "\tDN: %s\n", dn );
1120
1121 ufn = ldap_dn2ufn( dn );
1122 printf( "\tUFN: %s\n", ufn );
1123 free( dn );
1124 free( ufn );
1125
1126 if ( e->lm_msgtype == LDAP_RES_SEARCH_REFERENCE ){
1127 char **urls = ldap_get_reference_urls(ld, e);
1128 if (urls == NULL){
1129 printf("\t\tError with references: %s\n", ldap_err2string(ld->ld_errno));
1130 } else {
1131 for (i=0;urls[i] != NULL;i++)
1132 printf("\t\tURL: %s\n", urls[i]);
1133 }
1134 } else {
1135 for ( a = ldap_first_attribute( ld, e, &ber ); a != NULL;
1136 a = ldap_next_attribute( ld, e, ber ) ) {
1137 printf( "\t\tATTR: %s\n", a );
1138 if ( (vals = ldap_get_values_len( ld, e, a ))
1139 == NULL ) {
1140 printf( "\t\t\t(no values)\n" );
1141 } else {
1142 for ( i = 0; vals[i] != NULL; i++ ) {
1143 int j, nonascii;
1144
1145 nonascii = 0;
1146 for ( j = 0; j < vals[i]->bv_len; j++ )
1147 if ( !isascii( vals[i]->bv_val[j] ) ) {
1148 nonascii = 1;
1149 break;
1150 }
1151
1152 if ( nonascii ) {
1153 printf( "\t\t\tlength (%ld) (not ascii)\n", vals[i]->bv_len );
1154 #ifdef BPRINT_NONASCII
1155 lber_bprint( vals[i]->bv_val,
1156 vals[i]->bv_len );
1157 #endif /* BPRINT_NONASCII */
1158 continue;
1159 }
1160 printf( "\t\t\tlength (%ld) %s\n",
1161 vals[i]->bv_len, vals[i]->bv_val );
1162 }
1163 ber_bvecfree( vals );
1164 }
1165 }
1166 }
1167 }
1168
1169 if ( res->lm_msgtype == LDAP_RES_SEARCH_RESULT
1170 || res->lm_chain != NULLMSG )
1171 print_ldap_result( ld, res, "search" );
1172 }
1173