OpenSolaris_b135/cmd/ldap/common/ldapsearch.c
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998-1999 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
/* ldapsearch.c - generic program to search LDAP */
#include "ldaptool.h"
#include "fileurl.h"
#ifdef SOLARIS_LDAP_CMD
#include <locale.h>
#include "solaris-int.h"
#endif /* SOLARIS_LDAP_CMD */
#define VLV_PARAM_SEP ':'
#ifndef SOLARIS_LDAP_CMD
#define gettext(s) s
#endif
static void usage( void );
static int dosearch( LDAP *ld, char *base, int scope, char **attrs,
int attrsonly, char *filtpatt, char *value);
static void write_string_attr_value( char *attrname, char *strval,
unsigned long opts );
#define LDAPTOOL_WRITEVALOPT_SUPPRESS_NAME 0x01
static int write_ldif_value( char *type, char *value, unsigned long vallen,
unsigned long ldifoptions );
static void print_entry( LDAP *ld, LDAPMessage *entry, int attrsonly );
static void options_callback( int option, char *optarg );
static void parse_and_display_reference( LDAP *ld, LDAPMessage *ref );
static char *sortresult2string(unsigned long result);
static char *changetype_num2string( int chgtype );
static char *msgtype2str( int msgtype );
static char **get_effectiverights_attrlist(char * optarg);
#ifdef SOLARIS_LDAP_CMD
static void fill_ldapsearch_msgtypes( void );
#endif /* SOLARIS_LDAP_CMD */
/*
* Prefix used in names of pseudo attributes added to the entry LDIF
* output if we receive an entryChangeNotification control with an entry
* (requested using persistent search).
*/
#define LDAPTOOL_PSEARCH_ATTR_PREFIX "persistentSearch-"
static void
usage( void )
{
fprintf( stderr, gettext("usage: %s -b basedn [options] filter [attributes...]\n"), ldaptool_progname );
fprintf( stderr, gettext(" %s -b basedn [options] -f file [attributes...]\nwhere:\n"), ldaptool_progname );
fprintf( stderr, gettext(" basedn\tbase dn for search\n") );
fprintf( stderr, gettext("\t\t(if the environment variable LDAP_BASEDN is set,\n") );
fprintf( stderr, gettext("\t\tthen the -b flag is not required)\n") );
fprintf( stderr, gettext(" filter\tRFC-2254 compliant LDAP search filter\n") );
fprintf( stderr, gettext(" file\tfile containing a sequence of LDAP search filters to use\n") );
fprintf( stderr, gettext(" attributes\twhitespace-separated list of attributes to retrieve\n") );
fprintf( stderr, gettext("\t\t(if no attribute list is given, all are retrieved)\n") );
fprintf( stderr, gettext("options:\n") );
ldaptool_common_usage( 0 );
#if defined( XP_WIN32 )
fprintf( stderr, gettext(" -t\t\twrite values to files in temp directory.\n") );
#else
fprintf( stderr, gettext(" -t\t\twrite values to files in /tmp\n") );
#endif
fprintf( stderr, gettext(" -U\t\tproduce file URLs in conjunction with -t\n") );
fprintf( stderr, gettext(" -e\t\tminimize base-64 encoding of values\n") );
fprintf( stderr, gettext(" -u\t\tinclude User Friendly entry names in the output\n") );
#ifndef HAVE_SASL_OPTIONS
fprintf( stderr, gettext(" -o\t\tprint entries using old format (default is LDIF)\n") );
#endif
fprintf( stderr, gettext(" -T\t\tdon't fold (wrap) long lines (default is to fold)\n") );
fprintf( stderr, gettext(" -1\t\tomit leading \"version: %d\" line in LDIF output\n"), LDIF_VERSION_ONE );
fprintf( stderr, gettext(" -A\t\tretrieve attribute names only (no values)\n") );
fprintf( stderr, gettext(" -B\t\tprint non-ASCII values and use old output format (attr=value)\n") );
fprintf( stderr, gettext(" -x\t\tperforming sorting on server\n") );
#ifdef SOLARIS_LDAP_CMD
fprintf( stderr, gettext(" -r\t\tprint entries using old format (default is LDIF)\n") );
#endif /* SOLARIS_LDAP_CMD */
fprintf( stderr, gettext(" -F sep\tprint `sep' instead of `%s' between attribute names\n"), LDAPTOOL_DEFSEP );
fprintf( stderr, gettext(" \tand values\n") );
fprintf( stderr, gettext(" -S attr\tsort the results by attribute `attr'\n") );
fprintf( stderr, gettext(" -s scope\tone of base, one, or sub (default is sub)\n") );
fprintf( stderr, gettext(" -a deref\tone of never, always, search, or find (default: never)\n") );
fprintf( stderr, gettext(" \t(alias dereferencing)\n") );
fprintf( stderr, gettext(" -l timelim\ttime limit (in seconds) for search (default is no limit)\n") );
fprintf( stderr, gettext(" -z sizelim\tsize limit (in entries) for search (default is no limit)\n") );
fprintf( stderr, gettext(" -C ps:changetype[:changesonly[:entrychgcontrols]]\n") );
fprintf( stderr, gettext("\t\tchangetypes are add,delete,modify,moddn,any\n") );
fprintf( stderr, gettext("\t\tchangesonly and entrychgcontrols are boolean values\n") );
fprintf( stderr, gettext("\t\t(default is 1)\n") );
fprintf( stderr, gettext(" -G before%cafter%cindex%ccount | before%cafter%cvalue where 'before' and\n"), VLV_PARAM_SEP, VLV_PARAM_SEP, VLV_PARAM_SEP, VLV_PARAM_SEP, VLV_PARAM_SEP );
fprintf( stderr, gettext("\t\t'after' are the number of entries surrounding 'index.'\n"));
fprintf( stderr, gettext("\t\t'count' is the content count, 'value' is the search value.\n"));
#ifndef SOLARIS_LDAP_CMD
fprintf( stderr, gettext(" -c authzid\tspecifies the getEffectiveRights control authzid\n"));
fprintf( stderr, gettext("\t\t eg. dn:uid=bjensen,dc=example,dc=com\n"));
fprintf( stderr, gettext("\t\t A value of \"\" means \"the authorization id for the operation\".\n"));
fprintf( stderr, gettext("\t\t A value of \"dn:\" means \"anonymous\"\n"));
fprintf( stderr, gettext("\t\t (The aclRights operational attribute must be requested)\n"));
fprintf( stderr, gettext(" -X attrlist\tspecifies the getEffectiveRights control specific attribute list.\n"));
fprintf( stderr, gettext("\t\t eg. \"nsroledn userPassword\"\n"));
#endif /* SOLARIS_LDAP_CMD */
exit( LDAP_PARAM_ERROR );
}
static char *base = NULL;
static char *sep = LDAPTOOL_DEFSEP;
static char **sortattr = NULL;
static char *vlv_value = NULL;
static int sortsize = 0;
static int *skipsortattr = NULL;
static int includeufn, allow_binary, vals2tmp, ldif, scope, deref;
static int attrsonly, timelimit, sizelimit, server_sort, fold;
static int minimize_base64, produce_file_urls;
static int use_vlv = 0, vlv_before, vlv_after, vlv_index, vlv_count;
static int use_psearch=0;
static int write_ldif_version = 1;
#ifndef SOLARIS_LDAP_CMD
static char *get_effectiverights_control_target_dn = NULL; /* -c */
static char **get_effectiverights_control_attrlist = NULL; /* -X */
static int do_effective_rights_control = 0;
#endif /* SOLARIS_LDAP_CMD */
/* Persistent search variables */
static int chgtype=0, changesonly=1, return_echg_ctls=1;
int
main( int argc, char **argv )
{
char *filtpattern, **attrs;
int rc, optind, i, first, free_filtpattern;
LDAP *ld;
#ifdef SOLARIS_LDAP_CMD
char *locale = setlocale(LC_ALL, "");
textdomain(TEXT_DOMAIN);
ldaptool_require_binddn = 0;
#endif /* SOLARIS_LDAP_CMD */
free_filtpattern = 0;
deref = LDAP_DEREF_NEVER;
allow_binary = vals2tmp = attrsonly = 0;
minimize_base64 = produce_file_urls = 0;
ldif = 1;
fold = 1;
sizelimit = timelimit = 0;
scope = LDAP_SCOPE_SUBTREE;
server_sort = 0;
#ifdef notdef
#ifdef HPUX11
#ifndef __LP64__
_main( argc, argv);
#endif /* __LP64_ */
#endif /* HPUX11 */
#endif
ldaptool_reset_control_array( ldaptool_request_ctrls );
#ifdef HAVE_SASL_OPTIONS
#ifdef SOLARIS_LDAP_CMD
optind = ldaptool_process_args( argc, argv, "ABLTU1etuxra:b:F:G:l:S:s:z:C:",
0, options_callback );
#else
optind = ldaptool_process_args( argc, argv, "ABLTU1etuxa:b:F:G:l:S:s:z:C:c:",
0, options_callback );
#endif /* SOLARIS_LDAP_CMD */
#else
optind = ldaptool_process_args( argc, argv, "ABLTU1eotuxa:b:F:G:l:S:s:z:C:c:",
0, options_callback );
#endif /* HAVE_SASL_OPTIONS */
if ( optind == -1 ) {
usage();
}
if ( base == NULL ) {
if (( base = getenv( "LDAP_BASEDN" )) == NULL ) {
usage();
}
}
if ( sortattr ) {
for ( sortsize = 0; sortattr[sortsize] != NULL; sortsize++ ) {
; /* NULL */
}
sortsize++; /* add in the final NULL field */
skipsortattr = (int *) malloc( sortsize * sizeof(int *) );
if ( skipsortattr == NULL ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
memset( (char *) skipsortattr, 0, sortsize * sizeof(int *) );
} else if ( server_sort ) {
server_sort = 0; /* ignore this option if no sortattrs were given */
}
if ( argc - optind < 1 ) {
if ( ldaptool_fp == NULL ) {
usage();
}
attrs = NULL;
filtpattern = "%s";
} else { /* there are additional args (filter + attrs) */
if ( ldaptool_fp == NULL || strstr( argv[ optind ], "%s" ) != NULL ) {
filtpattern = ldaptool_local2UTF8( argv[ optind ] );
/* since local2UTF8 always allocates something, we should free it */
free_filtpattern = 1;
++optind;
} else {
filtpattern = "%s";
}
if ( argv[ optind ] == NULL ) {
attrs = NULL;
} else if ( sortattr == NULL || *sortattr == '\0' || server_sort) {
attrs = &argv[ optind ];
} else {
attrs = ldap_charray_dup( &argv[ optind ] );
if ( attrs == NULL ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
for ( i = 0; i < (sortsize - 1); i++ ) {
if ( !ldap_charray_inlist( attrs, sortattr[i] ) ) {
if ( ldap_charray_add( &attrs, sortattr[i] ) != 0 ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
/*
* attribute in the search list only for the purpose of
* sorting
*/
skipsortattr[i] = 1;
}
}
}
}
ld = ldaptool_ldap_init( 0 );
if ( !ldaptool_not ) {
ldap_set_option( ld, LDAP_OPT_DEREF, &deref );
ldap_set_option( ld, LDAP_OPT_TIMELIMIT, &timelimit );
ldap_set_option( ld, LDAP_OPT_SIZELIMIT, &sizelimit );
}
ldaptool_bind( ld );
if ( ldaptool_verbose ) {
printf( gettext("filter pattern: %s\nreturning: "), filtpattern );
if ( attrs == NULL ) {
printf( gettext("ALL") );
} else {
for ( i = 0; attrs[ i ] != NULL; ++i ) {
printf( "%s ", attrs[ i ] );
}
}
putchar( '\n' );
}
if ( ldaptool_fp == NULL ) {
char *conv;
conv = ldaptool_local2UTF8( base );
rc = dosearch( ld, conv, scope, attrs, attrsonly, filtpattern, "" );
if( conv != NULL )
free( conv );
} else {
int done = 0;
rc = LDAP_SUCCESS;
first = 1;
while ( rc == LDAP_SUCCESS && !done ) {
char *linep = NULL;
int increment = 0;
int c, index;
/* allocate initial block of memory */
if ((linep = (char *)malloc(BUFSIZ)) == NULL) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
increment++;
index = 0;
while ((c = fgetc( ldaptool_fp )) != '\n' && c != EOF) {
/* check if we will overflow the buffer */
if ((c != EOF) && (index == ((increment * BUFSIZ) -1))) {
/* if we did, add another BUFSIZ worth of bytes */
if ((linep = (char *)
realloc(linep, (increment + 1) * BUFSIZ)) == NULL) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
increment++;
}
linep[index++] = c;
}
if (c == EOF) {
done = 1;
break;
}
linep[index] = '\0';
if ( !first ) {
putchar( '\n' );
} else {
first = 0;
}
rc = dosearch( ld, base, scope, attrs, attrsonly, filtpattern,
linep );
free (linep);
}
}
ldaptool_cleanup( ld );
if (free_filtpattern != 0 && filtpattern != NULL) {
free (filtpattern);
}
/* check for and report output error */
fflush( stdout );
rc = ldaptool_check_ferror( stdout, rc,
gettext("output error (output might be incomplete)") );
return( rc );
}
static void
options_callback( int option, char *optarg )
{
char *s, *temp_arg, *ps_ptr, *ps_arg;
switch( option ) {
case 'u': /* include UFN */
++includeufn;
break;
case 't': /* write attribute values to /tmp files */
++vals2tmp;
break;
case 'U': /* produce file URLs in conjunction with -t */
++produce_file_urls;
break;
case 'e': /* minimize base-64 encoding of values */
++minimize_base64;
break;
case 'A': /* retrieve attribute names only -- no values */
++attrsonly;
break;
case 'L': /* print entries in LDIF format -- now the default */
break;
#ifdef SOLARIS_LDAP_CMD
case 'r': /* print entries in the old format */
ldif = 0;
break;
#endif /* SOLARIS_LDAP_CMD */
#ifdef HAVE_SASL_OPTIONS
#ifdef HAVE_SASL_OPTIONS_2
case 'o': /* print entries using old ldapsearch format */
ldif = 0;
break;
#endif
#else
case 'o': /* print entries using old ldapsearch format */
ldif = 0;
break;
#endif
case 'B': /* allow binary values to be printed, use old format */
++allow_binary;
ldif = 0;
break;
case '1': /* omit leading "version: #" line from LDIF output */
write_ldif_version = 0;
break;
case 's': /* search scope */
if ( strncasecmp( optarg, "base", 4 ) == 0 ) {
scope = LDAP_SCOPE_BASE;
} else if ( strncasecmp( optarg, "one", 3 ) == 0 ) {
scope = LDAP_SCOPE_ONELEVEL;
} else if ( strncasecmp( optarg, "sub", 3 ) == 0 ) {
scope = LDAP_SCOPE_SUBTREE;
} else {
fprintf( stderr, gettext("scope should be base, one, or sub\n") );
usage();
}
break;
case 'a': /* set alias deref option */
if ( strncasecmp( optarg, "never", 5 ) == 0 ) {
deref = LDAP_DEREF_NEVER;
} else if ( strncasecmp( optarg, "search", 5 ) == 0 ) {
deref = LDAP_DEREF_SEARCHING;
} else if ( strncasecmp( optarg, "find", 4 ) == 0 ) {
deref = LDAP_DEREF_FINDING;
} else if ( strncasecmp( optarg, "always", 6 ) == 0 ) {
deref = LDAP_DEREF_ALWAYS;
} else {
fprintf( stderr, gettext("alias deref should be never, search, find, or always\n") );
usage();
}
break;
case 'F': /* field separator */
sep = strdup( optarg );
ldif = 0;
break;
#ifndef SOLARIS_LDAP_CMD
case 'c':
if ( optarg && optarg[0] == '\0' ) {
/* -c ""
means "This user"
*/
get_effectiverights_control_target_dn = NULL;
do_effective_rights_control = 1;
}else if ( strlen(optarg) < 3 || (strncasecmp(optarg, "dn:", 3) != 0) ) {
fprintf(stderr, gettext("-c wrong format--should be \"\" or \"dn:...\".\n"
"\"dn:\" means anonymous user."));
usage();
} else {
get_effectiverights_control_target_dn = strdup(optarg);
do_effective_rights_control = 1;
}
break;
case 'X':
get_effectiverights_control_attrlist = get_effectiverights_attrlist(optarg);
do_effective_rights_control = 1;
break;
#endif /* SOLARIS_LDAP_CMD */
case 'b': /* searchbase */
base = strdup( optarg );
break;
case 'l': /* time limit */
timelimit = atoi( optarg );
break;
case 'x': /* server sorting requested */
server_sort = 1;
break;
case 'z': /* size limit */
sizelimit = atoi( optarg );
break;
case 'S': /* sort attribute */
ldap_charray_add( &sortattr, strdup( optarg ) );
break;
case 'T': /* don't fold lines */
fold = 0;
break;
case 'G': /* do the virtual list setup */
use_vlv++;
s = strchr(optarg, VLV_PARAM_SEP );
if (s != NULL)
{
vlv_before = atoi(optarg);
s++;
vlv_after = atoi( s );
s = strchr(s, VLV_PARAM_SEP );
if (s != NULL)
{
s++;
/* below is a small set of logic to implement the following cases
* -G23:23:wilber
* -G23:23:"wilber:wright"
* -G23:23:'wilber'
* -G23:23:wilber wright
* all of the above are before, after, value - NOTE: a colon not in a quoted
* string will break the parser!!!!
* -G23:23:45:600
* above is index, count encoding
*/
if (*s == '\'' || *s == '"')
{
vlv_value = strdup( s );
}
else
{
if (strchr( s, VLV_PARAM_SEP ))
{
/* we have an index + count option */
vlv_index = atoi( s );
vlv_count = atoi( strchr( s, VLV_PARAM_SEP) + 1);
}
else
{
/* we don't have a quote surrounding the assertion value
* do we need to???
*/
vlv_value = strdup( s );
}
}
}
else
{
fprintf( stderr,gettext("Illegal 'after' paramater for virtual list\n") );
exit( LDAP_PARAM_ERROR );
}
}
else
{
fprintf( stderr,gettext("Illegal 'before' paramater for virtual list\n") );
exit( LDAP_PARAM_ERROR );
}
break;
case 'C':
use_psearch++;
if ( (ps_arg = strdup( optarg)) == NULL ) {
perror ("strdup");
exit (LDAP_NO_MEMORY);
}
ps_ptr=strtok(ps_arg, ":");
if (ps_ptr == NULL || (strcasecmp(ps_ptr, "ps")) ) {
fprintf (stderr, gettext("Invalid argument for -C\n"));
usage();
}
if (NULL != (ps_ptr=strtok(NULL, ":"))) {
if ( (temp_arg = strdup( ps_ptr )) == NULL ) {
perror ("strdup");
exit (LDAP_NO_MEMORY);
}
} else {
fprintf (stderr, gettext("Invalid argument for -C\n"));
usage();
}
if (NULL != (ps_ptr=strtok(NULL, ":"))) {
if ( (changesonly = ldaptool_boolean_str2value(ps_ptr, 0)) == -1) {
fprintf(stderr, gettext("Invalid option value: %s\n"), ps_ptr);
usage();
}
}
if (NULL != (ps_ptr=strtok(NULL, ":"))) {
if ( (return_echg_ctls = ldaptool_boolean_str2value(ps_ptr, 0)) == -1) {
fprintf(stderr, gettext("Invalid option value: %s\n"), ps_ptr);
usage();
}
}
/* Now parse the temp_arg and build chgtype as
* the changetypes are encountered */
if ((ps_ptr = strtok( temp_arg, "," )) == NULL) {
usage();
} else {
while ( ps_ptr ) {
if ((strcasecmp(ps_ptr, "add"))==0)
chgtype |= LDAP_CHANGETYPE_ADD;
else if ((strcasecmp(ps_ptr, "delete"))==0)
chgtype |= LDAP_CHANGETYPE_DELETE;
else if ((strcasecmp(ps_ptr, "modify"))==0)
chgtype |= LDAP_CHANGETYPE_MODIFY;
else if ((strcasecmp(ps_ptr, "moddn"))==0)
chgtype |= LDAP_CHANGETYPE_MODDN;
else if ((strcasecmp(ps_ptr, "any"))==0)
chgtype = LDAP_CHANGETYPE_ANY;
else {
fprintf(stderr, gettext("Unknown changetype: %s\n"), ps_ptr);
usage();
}
ps_ptr = strtok( NULL, "," );
}
}
break;
default:
usage();
break;
}
}
static int
dosearch( ld, base, scope, attrs, attrsonly, filtpatt, value )
LDAP *ld;
char *base;
int scope;
char **attrs;
int attrsonly;
char *filtpatt;
char *value;
{
char **refs = NULL, filter[ BUFSIZ ], *filterp = NULL;
int rc, first, matches;
LDAPMessage *res, *e;
LDAPControl *ldctrl;
LDAPControl **ctrl_response_array = NULL;
LDAPVirtualList vlv_data;
int msgid = 0;
int length = 0;
int mallocd_filter = 0;
if ( strstr( filtpatt, "%s" ) == NULL ) { /* no need to sprintf() */
filterp = filtpatt;
} else {
length = strlen( filtpatt ) + strlen ( value ) +1;
if ( length > BUFSIZ ) {
if ((filterp = (char *)
malloc ( length )) == NULL) {
perror( gettext("filter and/or pattern too long?") );
exit (LDAP_PARAM_ERROR);
}
mallocd_filter = 1;
} else {
filterp = filter;
}
#ifdef HAVE_SNPRINTF
if ( snprintf( filterp, length, filtpatt, value ) < 0 ) {
perror( gettext("snprintf filter (filter and/or pattern too long?)") );
exit( LDAP_PARAM_ERROR );
}
#else
sprintf( filterp, filtpatt, value );
#endif
}
if ( *filterp == '\0' ) { /* treat empty filter is a shortcut for oc=* */
if (mallocd_filter) {
free(filterp);
mallocd_filter = 0;
}
filterp = "(objectclass=*)";
}
if ( ldaptool_verbose ) {
/*
* Display the filter that will be used. Add surrounding parens.
* if they are missing.
*/
if ( '(' == *filterp ) {
printf( "filter is: %s\n", filterp );
} else {
printf( "filter is: (%s)\n", filterp );
}
}
if ( ldaptool_not ) {
if (mallocd_filter) free(filterp);
return( LDAP_SUCCESS );
}
if (( ldctrl = ldaptool_create_manage_dsait_control()) != NULL ) {
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
if ((ldctrl = ldaptool_create_proxyauth_control(ld)) !=NULL) {
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
#ifndef SOLARIS_LDAP_CMD
if ( do_effective_rights_control ) {
if ((ldctrl = ldaptool_create_geteffectiveRights_control(ld,
get_effectiverights_control_target_dn,
(const char**) get_effectiverights_control_attrlist)) !=NULL) {
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
}
#endif /* SOLARIS_LDAP_CMD */
if (use_psearch) {
if ( ldap_create_persistentsearch_control( ld, chgtype,
changesonly, return_echg_ctls,
1, &ldctrl ) != LDAP_SUCCESS )
{
ldap_perror( ld, "ldap_create_persistentsearch_control" );
return (1);
}
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
if (server_sort) {
/* First make a sort key list from the attribute list we have */
LDAPsortkey **keylist = NULL;
int i = 0;
char *sortattrs = NULL;
char *s = NULL;
int string_length = 0;
/* Count the sort strings */
for (i = 0; i < sortsize - 1 ; i++) {
string_length += strlen(sortattr[i]) + 1;
}
sortattrs = (char *) malloc(string_length + 1);
if (NULL == sortattrs) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
s = sortattrs;
for (i = 0; i < sortsize - 1 ; i++) {
memcpy(s, sortattr[i], strlen(sortattr[i]));
s += strlen(sortattr[i]);
*s++ = ' ';
}
sortattrs[string_length] = '\0';
ldap_create_sort_keylist(&keylist,sortattrs);
free(sortattrs);
sortattrs = NULL;
/* Then make a control for the sort attributes we have */
rc = ldap_create_sort_control(ld,keylist,0,&ldctrl);
ldap_free_sort_keylist(keylist);
if ( rc != LDAP_SUCCESS ) {
if (mallocd_filter) free(filterp);
return( ldaptool_print_lderror( ld, "ldap_create_sort_control",
LDAPTOOL_CHECK4SSL_IF_APPROP ));
}
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
/* remember server side sorting must be available for vlv!!!! */
if (use_vlv)
{
vlv_data.ldvlist_before_count = vlv_before;
vlv_data.ldvlist_after_count = vlv_after;
if ( ldaptool_verbose ) {
printf( gettext("vlv data %lu, %lu, "),
vlv_data.ldvlist_before_count,
vlv_data.ldvlist_after_count
);
}
if (vlv_value)
{
vlv_data.ldvlist_attrvalue = vlv_value;
vlv_data.ldvlist_size = 0;
vlv_data.ldvlist_index = 0;
if ( ldaptool_verbose ) {
printf( "%s, 0, 0\n", vlv_data.ldvlist_attrvalue);
}
}
else
{
vlv_data.ldvlist_attrvalue = NULL;
vlv_data.ldvlist_size = vlv_count;
vlv_data.ldvlist_index = vlv_index;
if ( ldaptool_verbose ) {
printf( "(null), %lu, %lu\n", vlv_data.ldvlist_size, vlv_data.ldvlist_index );
}
}
if ( rc != LDAP_SUCCESS ) {
if (mallocd_filter) free(filterp);
return( ldaptool_print_lderror( ld, "ldap_create_sort_control",
LDAPTOOL_CHECK4SSL_IF_APPROP ));
}
if (LDAP_SUCCESS != (rc = ldap_create_virtuallist_control(ld,
&vlv_data, &ldctrl)))
{
if (mallocd_filter) free(filterp);
return( ldaptool_print_lderror( ld,
"ldap_create_virtuallist_control",
LDAPTOOL_CHECK4SSL_IF_APPROP ));
}
ldaptool_add_control_to_array(ldctrl, ldaptool_request_ctrls);
}
if ( ldap_search_ext( ld, base, scope, filterp, attrs, attrsonly,
ldaptool_request_ctrls, NULL, NULL, -1, &msgid )
!= LDAP_SUCCESS ) {
if (mallocd_filter) free(filterp);
return( ldaptool_print_lderror( ld, "ldap_search",
LDAPTOOL_CHECK4SSL_IF_APPROP ));
}
matches = 0;
first = 1;
if ( sortattr && !server_sort ) {
rc = ldap_result( ld, LDAP_RES_ANY, 1, NULL, &res );
} else {
while ( (rc = ldap_result( ld, LDAP_RES_ANY, 0, NULL, &res )) !=
LDAP_RES_SEARCH_RESULT && rc != -1 ) {
if ( rc != LDAP_RES_SEARCH_ENTRY ) {
if ( rc == LDAP_RES_SEARCH_REFERENCE ) {
parse_and_display_reference( ld, res );
} else if ( rc == LDAP_RES_EXTENDED
&& ldap_msgid( res ) == LDAP_RES_UNSOLICITED ) {
ldaptool_print_extended_response( ld, res,
gettext("Unsolicited response") );
} else {
fprintf( stderr, gettext("%s: ignoring LDAP response message"
" type 0x%x (%s)\n"),
ldaptool_progname, rc, msgtype2str( rc ));
}
ldap_msgfree( res );
continue;
}
matches++;
e = ldap_first_entry( ld, res );
if ( !first ) {
putchar( '\n' );
} else {
first = 0;
}
print_entry( ld, e, attrsonly );
ldap_msgfree( res );
}
}
if ( rc == -1 ) {
if (mallocd_filter) free(filterp);
return( ldaptool_print_lderror( ld, "ldap_result",
LDAPTOOL_CHECK4SSL_IF_APPROP ));
}
if ( ldap_parse_result( ld, res, &rc, NULL, NULL, &refs,
&ctrl_response_array, 0 ) != LDAP_SUCCESS ) {
ldaptool_print_lderror( ld, "ldap_parse_result",
LDAPTOOL_CHECK4SSL_IF_APPROP );
} else if ( rc != LDAP_SUCCESS ) {
ldaptool_print_lderror( ld, "ldap_search",
LDAPTOOL_CHECK4SSL_IF_APPROP );
}
/* Parse the returned sort control */
if (server_sort) {
unsigned long result = 0;
char *attribute;
if ( LDAP_SUCCESS != ldap_parse_sort_control(ld,ctrl_response_array,&result,&attribute) ) {
ldaptool_print_lderror(ld, "ldap_parse_sort_control",
LDAPTOOL_CHECK4SSL_IF_APPROP );
ldap_controls_free(ctrl_response_array);
ldap_msgfree(res);
if (mallocd_filter) free(filterp);
return ( ldap_get_lderrno( ld, NULL, NULL ) );
}
if (0 == result) {
if ( ldaptool_verbose ) {
printf( gettext("Server indicated results sorted OK\n"));
}
} else {
if (NULL != attribute) {
printf(gettext("Server reported sorting error %ld: %s, attribute in error\"%s\"\n"),result,sortresult2string(result),attribute);
} else {
printf(gettext("Server reported sorting error %ld: %s\n"),result,sortresult2string(result));
}
}
}
if (use_vlv)
{
unsigned long vpos, vcount;
int vresult;
if ( LDAP_SUCCESS != ldap_parse_virtuallist_control(ld,ctrl_response_array,&vpos, &vcount,&vresult) ) {
ldaptool_print_lderror( ld, "ldap_parse_virtuallist_control",
LDAPTOOL_CHECK4SSL_IF_APPROP );
ldap_controls_free(ctrl_response_array);
ldap_msgfree(res);
if (mallocd_filter) free(filterp);
return ( ldap_get_lderrno( ld, NULL, NULL ) );
}
if (0 == vresult) {
if ( ldaptool_verbose ) {
printf( gettext("Server indicated virtual list positioning OK\n"));
}
printf(gettext("index %lu content count %lu\n"), vpos, vcount);
} else {
printf(gettext("Server reported sorting error %d: %s\n"),vresult,sortresult2string(vresult));
}
}
ldap_controls_free(ctrl_response_array);
if ( sortattr != NULL && !server_sort) {
(void) ldap_multisort_entries( ld, &res,
( *sortattr == NULL ) ? NULL : sortattr,
(LDAP_CMP_CALLBACK *)strcasecmp );
matches = 0;
first = 1;
for ( e = ldap_first_entry( ld, res ); e != NULLMSG;
e = ldap_next_entry( ld, e ) ) {
matches++;
if ( !first ) {
putchar( '\n' );
} else {
first = 0;
}
print_entry( ld, e, attrsonly );
}
}
if ( ldaptool_verbose ) {
printf( gettext("%d matches\n"), matches );
}
if ( refs != NULL ) {
ldaptool_print_referrals( refs );
ldap_value_free( refs );
}
if (mallocd_filter) free(filterp);
ldap_msgfree( res );
return( rc );
}
static void
print_entry( ld, entry, attrsonly )
LDAP *ld;
LDAPMessage *entry;
int attrsonly;
{
char *a, *dn, *ufn, tmpfname[ BUFSIZ ];
int i, notascii;
BerElement *ber;
struct berval **bvals;
FILE *tmpfp;
#if defined( XP_WIN32 )
char mode[20] = "w+b";
#else
char mode[20] = "w";
#endif
dn = ldap_get_dn( ld, entry );
write_string_attr_value( "dn", dn, LDAPTOOL_WRITEVALOPT_SUPPRESS_NAME );
if ( includeufn ) {
ufn = ldap_dn2ufn( dn );
write_string_attr_value( "ufn", ufn,
LDAPTOOL_WRITEVALOPT_SUPPRESS_NAME );
free( ufn );
}
ldap_memfree( dn );
if ( use_psearch ) {
LDAPControl **ectrls;
int chgtype, chgnumpresent;
#ifdef SOLARIS_LDAP_CMD
ber_int_t chgnum;
#else
long chgnum;
#endif /* SOLARIS_LDAP_CMD */
char *prevdn, longbuf[ 128 ];
if ( ldap_get_entry_controls( ld, entry, &ectrls ) == LDAP_SUCCESS ) {
if ( ldap_parse_entrychange_control( ld, ectrls, &chgtype,
&prevdn, &chgnumpresent, &chgnum ) == LDAP_SUCCESS ) {
write_string_attr_value(
LDAPTOOL_PSEARCH_ATTR_PREFIX "changeType",
changetype_num2string( chgtype ), 0 );
if ( chgnumpresent ) {
sprintf( longbuf, "%d", chgnum );
write_string_attr_value(
LDAPTOOL_PSEARCH_ATTR_PREFIX "changeNumber",
longbuf, 0 );
}
if ( NULL != prevdn ) {
write_string_attr_value(
LDAPTOOL_PSEARCH_ATTR_PREFIX "previousDN",
prevdn, 0 );
ldap_memfree( prevdn );
}
}
ldap_controls_free (ectrls);
}
}
for ( a = ldap_first_attribute( ld, entry, &ber ); a != NULL;
a = ldap_next_attribute( ld, entry, ber ) ) {
if ( ldap_charray_inlist(sortattr, a) && /* in the list*/
skipsortattr[ldap_charray_position(sortattr, a)] ) {/* and skip it*/
continue; /* so skip it! */
}
if ( attrsonly ) {
if ( ldif ) {
write_ldif_value( a, "", 0, 0 );
} else {
printf( "%s\n", a );
}
} else if (( bvals = ldap_get_values_len( ld, entry, a )) != NULL ) {
for ( i = 0; bvals[i] != NULL; i++ ) {
if ( vals2tmp ) {
#ifdef HAVE_SNPRINTF
if ( snprintf( tmpfname, sizeof(tmpfname),
"%s/ldapsearch-%s-XXXXXX",
ldaptool_get_tmp_dir(), a ) < 0 ) {
perror( gettext("snprintf tmpfname (attribute name too long?)") );
exit( LDAP_PARAM_ERROR );
}
#else
sprintf( tmpfname, "%s/ldapsearch-%s-XXXXXX",
ldaptool_get_tmp_dir(), a );
#endif
tmpfp = NULL;
if ( LDAPTOOL_MKTEMP( tmpfname ) == NULL ) {
perror( tmpfname );
} else if (( tmpfp = ldaptool_open_file( tmpfname, mode)) == NULL ) {
perror( tmpfname );
} else if ( bvals[ i ]->bv_len > 0 &&
fwrite( bvals[ i ]->bv_val,
bvals[ i ]->bv_len, 1, tmpfp ) == 0 ) {
perror( tmpfname );
} else if ( ldif ) {
if ( produce_file_urls ) {
char *url;
if ( ldaptool_path2fileurl( tmpfname, &url ) !=
LDAPTOOL_FILEURL_SUCCESS ) {
perror( "ldaptool_path2fileurl" );
} else {
write_ldif_value( a, url, strlen( url ),
LDIF_OPT_VALUE_IS_URL );
free( url );
}
} else {
write_ldif_value( a, tmpfname, strlen( tmpfname ),
0 );
}
} else {
printf( "%s%s%s\n", a, sep, tmpfname );
}
if ( tmpfp != NULL ) {
fclose( tmpfp );
}
} else {
notascii = 0;
if ( !ldif && !allow_binary ) {
notascii = !ldaptool_berval_is_ascii( bvals[i] );
}
if ( ldif ) {
write_ldif_value( a, bvals[ i ]->bv_val,
bvals[ i ]->bv_len, 0 );
} else {
printf( "%s%s%s\n", a, sep,
notascii ? gettext("NOT ASCII") : bvals[ i ]->bv_val );
}
}
}
ber_bvecfree( bvals );
}
ldap_memfree( a );
}
if ( ldap_get_lderrno( ld, NULL, NULL ) != LDAP_SUCCESS ) {
ldaptool_print_lderror( ld, "ldap_first_attribute/ldap_next_attribute",
LDAPTOOL_CHECK4SSL_IF_APPROP );
}
if ( ber != NULL ) {
ber_free( ber, 0 );
}
}
static void
write_string_attr_value( char *attrname, char *strval, unsigned long opts )
{
if ( strval == NULL ) {
strval = "";
}
if ( ldif ) {
write_ldif_value( attrname, strval, strlen( strval ), 0 );
} else if ( 0 != ( opts & LDAPTOOL_WRITEVALOPT_SUPPRESS_NAME )) {
printf( "%s\n", strval );
} else {
printf( "%s%s%s\n", attrname, sep, strval );
}
}
static int
write_ldif_value( char *type, char *value, unsigned long vallen,
unsigned long ldifoptions )
{
char *ldif;
static int wrote_version = 0;
if ( write_ldif_version && !wrote_version ) {
char versionbuf[ 64 ];
wrote_version = 1;
sprintf( versionbuf, "%d", LDIF_VERSION_ONE );
write_ldif_value( "version", versionbuf, strlen( versionbuf ), 0 );
}
if ( !fold ) {
ldifoptions |= LDIF_OPT_NOWRAP;
}
if ( minimize_base64 ) {
ldifoptions |= LDIF_OPT_MINIMAL_ENCODING;
}
if (( ldif = ldif_type_and_value_with_options( type, value, (int)vallen,
ldifoptions )) == NULL ) {
return( -1 );
}
fputs( ldif, stdout );
free( ldif );
return( 0 );
}
static char *
sortresult2string(unsigned long result)
{
/*
success (0), -- results are sorted
operationsError (1), -- server internal failure
timeLimitExceeded (3), -- timelimit reached before
-- sorting was completed
strongAuthRequired (8), -- refused to return sorted
-- results via insecure
-- protocol
adminLimitExceeded (11), -- too many matching entries
-- for the server to sort
noSuchAttribute (16), -- unrecognized attribute
-- type in sort key
inappropriateMatching (18), -- unrecognized or inappro-
-- priate matching rule in
-- sort key
insufficientAccessRights (50), -- refused to return sorted
-- results to this client
busy (51), -- too busy to process
unwillingToPerform (53), -- unable to sort
other (80)
*/
switch (result) {
case 0: return (gettext("success"));
case 1: return (gettext("operations error"));
case 3: return (gettext("time limit exceeded"));
case 8: return (gettext("strong auth required"));
case 11: return (gettext("admin limit exceeded"));
case 16: return (gettext("no such attribute"));
case 18: return (gettext("unrecognized or inappropriate matching rule"));
case 50: return (gettext("insufficient access rights"));
case 51: return (gettext("too busy"));
case 53: return (gettext("unable to sort"));
case 80:
default: return (gettext("Er...Other ?"));
}
}
static void
parse_and_display_reference( LDAP *ld, LDAPMessage *ref )
{
int i;
char **refs;
if ( ldap_parse_reference( ld, ref, &refs, NULL, 0 ) != LDAP_SUCCESS ) {
ldaptool_print_lderror( ld, "ldap_parse_reference",
LDAPTOOL_CHECK4SSL_IF_APPROP );
} else if ( refs != NULL && refs[ 0 ] != NULL ) {
fputs( gettext("Unfollowed continuation reference(s):\n"), stderr );
for ( i = 0; refs[ i ] != NULL; ++i ) {
fprintf( stderr, " %s\n", refs[ i ] );
}
ldap_value_free( refs );
}
}
/*possible operations a client can invoke -- copied from ldaprot.h */
#ifndef LDAP_REQ_BIND
#define LDAP_REQ_BIND 0x60L /* application + constructed */
#define LDAP_REQ_UNBIND 0x42L /* application + primitive */
#define LDAP_REQ_SEARCH 0x63L /* application + constructed */
#define LDAP_REQ_MODIFY 0x66L /* application + constructed */
#define LDAP_REQ_ADD 0x68L /* application + constructed */
#define LDAP_REQ_DELETE 0x4aL /* application + primitive */
#define LDAP_REQ_RENAME 0x6cL /* application + constructed */
#define LDAP_REQ_COMPARE 0x6eL /* application + constructed */
#define LDAP_REQ_ABANDON 0x50L /* application + primitive */
#define LDAP_REQ_EXTENDED 0x77L /* application + constructed */
#endif /* LDAP_REQ_BIND */
struct ldapsearch_type2str {
int ldst2s_type; /* message type */
char *ldst2s_string; /* descriptive string */
};
#ifdef SOLARIS_LDAP_CMD
static struct ldapsearch_type2str ldapsearch_msgtypes[] = {
/* results: */
{ LDAP_RES_BIND, NULL },
{ LDAP_RES_SEARCH_REFERENCE, NULL },
{ LDAP_RES_SEARCH_ENTRY, NULL },
{ LDAP_RES_SEARCH_RESULT, NULL },
{ LDAP_RES_MODIFY, NULL },
{ LDAP_RES_ADD, NULL },
{ LDAP_RES_DELETE, NULL },
{ LDAP_RES_MODDN, NULL },
{ LDAP_RES_COMPARE, NULL },
{ LDAP_RES_EXTENDED, NULL },
/* requests: */
{ LDAP_REQ_BIND, NULL },
{ LDAP_REQ_UNBIND, NULL },
{ LDAP_REQ_SEARCH, NULL },
{ LDAP_REQ_MODIFY, NULL },
{ LDAP_REQ_ADD, NULL },
{ LDAP_REQ_DELETE, NULL },
{ LDAP_REQ_RENAME, NULL },
{ LDAP_REQ_COMPARE, NULL },
{ LDAP_REQ_ABANDON, NULL },
{ LDAP_REQ_EXTENDED, NULL },
};
#else
static struct ldapsearch_type2str ldapsearch_msgtypes[] = {
/* results: */
{ LDAP_RES_BIND, "bind result" },
{ LDAP_RES_SEARCH_REFERENCE, "continuation reference" },
{ LDAP_RES_SEARCH_ENTRY, "entry" },
{ LDAP_RES_SEARCH_RESULT, "search result" },
{ LDAP_RES_MODIFY, "modify result" },
{ LDAP_RES_ADD, "add result" },
{ LDAP_RES_DELETE, "delete result" },
{ LDAP_RES_MODDN, "rename result" },
{ LDAP_RES_COMPARE, "compare result" },
{ LDAP_RES_EXTENDED, "extended operation result" },
/* requests: */
{ LDAP_REQ_BIND, "bind request" },
{ LDAP_REQ_UNBIND, "unbind request" },
{ LDAP_REQ_SEARCH, "search request" },
{ LDAP_REQ_MODIFY, "modify request" },
{ LDAP_REQ_ADD, "add request" },
{ LDAP_REQ_DELETE, "delete request" },
{ LDAP_REQ_RENAME, "rename request" },
{ LDAP_REQ_COMPARE, "compare request" },
{ LDAP_REQ_ABANDON, "abandon request" },
{ LDAP_REQ_EXTENDED, "extended request" },
};
#endif /* SOLARIS_LDAP_CMD */
#define LDAPSEARCHTOOL_NUMTYPES (sizeof(ldapsearch_msgtypes) \
/ sizeof(struct ldapsearch_type2str))
#ifdef SOLARIS_LDAP_CMD
static void
fill_ldapsearch_msgtypes( void )
{
int i = 0;
if (ldapsearch_msgtypes[LDAPSEARCHTOOL_NUMTYPES - 1].ldst2s_string
!= NULL)
return;
/* results: */
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"bind result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"continuation reference");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"entry");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"search result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"modify result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"add result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"delete result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"rename result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"compare result");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"extended operation result");
/* requests: */
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"bind request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"unbind request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"search request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"modify request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"add request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"delete request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"rename request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"compare request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"abandon request");
ldapsearch_msgtypes[i++].ldst2s_string = gettext(
"extended request");
}
#endif /* SOLARIS_LDAP_CMD */
/*
* Return a descriptive string given an LDAP result message type (tag).
*/
static char *
msgtype2str( int msgtype )
{
char *s = gettext("unknown");
int i;
#ifdef SOLARIS_LDAP_CMD
/* Make sure ldapsearch_msgtypes is initialized */
if (ldapsearch_msgtypes[LDAPSEARCHTOOL_NUMTYPES - 1].ldst2s_string
== NULL)
(void) fill_ldapsearch_msgtypes();
#endif /* SOLARIS_LDAP_CMD */
for ( i = 0; i < LDAPSEARCHTOOL_NUMTYPES; ++i ) {
if ( msgtype == ldapsearch_msgtypes[ i ].ldst2s_type ) {
s = ldapsearch_msgtypes[ i ].ldst2s_string;
}
}
return( s );
}
/*
* Return a descriptive string given a Persistent Search change type
*/
static char *
changetype_num2string( int chgtype )
{
char *s = gettext("unknown");
switch( chgtype ) {
case LDAP_CHANGETYPE_ADD:
s = gettext("add");
break;
case LDAP_CHANGETYPE_DELETE:
s = gettext("delete");
break;
case LDAP_CHANGETYPE_MODIFY:
s = gettext("modify");
break;
case LDAP_CHANGETYPE_MODDN:
s = gettext("moddn");
break;
}
return( s );
}
/* returns a null teminated charrary */
static char **get_effectiverights_attrlist(char * optarg) {
char * tmp_str = strdup(optarg);
char ** retArray = NULL;
int i = 0;
retArray = ldap_str2charray( tmp_str, " "); /* takes copies */
free(tmp_str);
/* Oops - somebody left this debug message in for the
getEffectiveRights control
fprintf(stderr, "attrlist: "); */
i = 0;
while( retArray[i] != NULL ) {
fprintf(stderr,"%s ", retArray[i]);
i++;
}
fprintf(stderr, "\n");
return(retArray);
}