| | |
| | | |
| | | import static com.sun.opends.sdk.messages.Messages.*; |
| | | import static com.sun.opends.sdk.tools.ToolConstants.*; |
| | | import static com.sun.opends.sdk.tools.Utils.*; |
| | | import static com.sun.opends.sdk.tools.Utils.filterExitCode; |
| | | |
| | | import java.io.*; |
| | | import java.util.ArrayList; |
| | | import java.util.LinkedList; |
| | | import java.util.List; |
| | | import java.util.StringTokenizer; |
| | | import java.util.*; |
| | | |
| | | import org.opends.sdk.*; |
| | | import org.opends.sdk.controls.*; |
| | |
| | | import org.opends.sdk.responses.SearchResultEntry; |
| | | import org.opends.sdk.responses.SearchResultReference; |
| | | |
| | | import com.sun.opends.sdk.controls.AccountUsabilityResponseControl; |
| | | import com.sun.opends.sdk.util.StaticUtils; |
| | | |
| | | |
| | | |
| | | /** |
| | | * A tool that can be used to issue Search requests to the Directory |
| | | * Server. |
| | | * A tool that can be used to issue Search requests to the Directory Server. |
| | | */ |
| | | public final class LDAPSearch extends ConsoleApplication |
| | | { |
| | | private BooleanArgument verbose; |
| | | |
| | | private EntryWriter ldifWriter; |
| | | |
| | | |
| | | |
| | | private class LDAPSearchResultHandler implements SearchResultHandler |
| | | { |
| | | private int entryCount = 0; |
| | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public void handleEntry(SearchResultEntry entry) |
| | | public boolean handleEntry(final SearchResultEntry entry) |
| | | { |
| | | entryCount++; |
| | | |
| | | Control control = entry |
| | | .getControl(EntryChangeNotificationControl.OID_ENTRY_CHANGE_NOTIFICATION); |
| | | if (control != null |
| | | && control instanceof EntryChangeNotificationControl) |
| | | try |
| | | { |
| | | EntryChangeNotificationControl dc = (EntryChangeNotificationControl) control; |
| | | println(INFO_LDAPSEARCH_PSEARCH_CHANGE_TYPE.get(dc |
| | | .getChangeType().toString())); |
| | | String previousDN = dc.getPreviousDN(); |
| | | if (previousDN != null) |
| | | final EntryChangeNotificationResponseControl control = entry |
| | | .getControl(EntryChangeNotificationResponseControl.DECODER, |
| | | new DecodeOptions()); |
| | | if (control != null) |
| | | { |
| | | println(INFO_LDAPSEARCH_PSEARCH_PREVIOUS_DN.get(previousDN)); |
| | | println(INFO_LDAPSEARCH_PSEARCH_CHANGE_TYPE.get(control |
| | | .getChangeType().toString())); |
| | | final DN previousDN = control.getPreviousName(); |
| | | if (previousDN != null) |
| | | { |
| | | println(INFO_LDAPSEARCH_PSEARCH_PREVIOUS_DN.get(previousDN |
| | | .toString())); |
| | | } |
| | | } |
| | | } |
| | | control = entry |
| | | .getControl(AccountUsabilityControl.OID_ACCOUNT_USABLE_CONTROL); |
| | | if (control != null |
| | | && control instanceof AccountUsabilityControl.Response) |
| | | catch (final DecodeException de) |
| | | { |
| | | AccountUsabilityControl.Response dc = (AccountUsabilityControl.Response) control; |
| | | println(ERR_DECODE_CONTROL_FAILURE.get(de.getLocalizedMessage())); |
| | | } |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_HEADER.get()); |
| | | if (dc.isUsable()) |
| | | try |
| | | { |
| | | final AccountUsabilityResponseControl control = entry.getControl( |
| | | AccountUsabilityResponseControl.DECODER, new DecodeOptions()); |
| | | |
| | | if (control != null) |
| | | { |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_IS_USABLE.get()); |
| | | if (dc.getSecondsBeforeExpiration() > 0) |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_HEADER.get()); |
| | | if (control.isUsable()) |
| | | { |
| | | int timeToExp = dc.getSecondsBeforeExpiration(); |
| | | LocalizableMessage timeToExpStr = Utils.secondsToTimeString(timeToExp); |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_TIME_UNTIL_EXPIRATION |
| | | .get(timeToExpStr)); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_NOT_USABLE.get()); |
| | | if (dc.isInactive()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_ACCT_INACTIVE.get()); |
| | | } |
| | | if (dc.isReset()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_PW_RESET.get()); |
| | | } |
| | | if (dc.isExpired()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_PW_EXPIRED.get()); |
| | | |
| | | if (dc.getRemainingGraceLogins() > 0) |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_IS_USABLE.get()); |
| | | if (control.getSecondsBeforeExpiration() > 0) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_REMAINING_GRACE.get(dc |
| | | .getRemainingGraceLogins())); |
| | | final int timeToExp = control.getSecondsBeforeExpiration(); |
| | | final LocalizableMessage timeToExpStr = Utils |
| | | .secondsToTimeString(timeToExp); |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_TIME_UNTIL_EXPIRATION |
| | | .get(timeToExpStr)); |
| | | } |
| | | } |
| | | if (dc.isLocked()) |
| | | else |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_LOCKED.get()); |
| | | if (dc.getSecondsBeforeUnlock() > 0) |
| | | { |
| | | int timeToUnlock = dc.getSecondsBeforeUnlock(); |
| | | LocalizableMessage timeToUnlockStr = Utils |
| | | .secondsToTimeString(timeToUnlock); |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_TIME_UNTIL_UNLOCK |
| | | .get(timeToUnlockStr)); |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_NOT_USABLE.get()); |
| | | if (control.isInactive()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_ACCT_INACTIVE.get()); |
| | | } |
| | | if (control.isReset()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_PW_RESET.get()); |
| | | } |
| | | if (control.isExpired()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_PW_EXPIRED.get()); |
| | | |
| | | if (control.getRemainingGraceLogins() > 0) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_REMAINING_GRACE.get(control |
| | | .getRemainingGraceLogins())); |
| | | } |
| | | } |
| | | if (control.isLocked()) |
| | | { |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_LOCKED.get()); |
| | | if (control.getSecondsBeforeUnlock() > 0) |
| | | { |
| | | final int timeToUnlock = control.getSecondsBeforeUnlock(); |
| | | final LocalizableMessage timeToUnlockStr = Utils |
| | | .secondsToTimeString(timeToUnlock); |
| | | |
| | | println(INFO_LDAPSEARCH_ACCTUSABLE_TIME_UNTIL_UNLOCK |
| | | .get(timeToUnlockStr)); |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | catch (final DecodeException de) |
| | | { |
| | | println(ERR_DECODE_CONTROL_FAILURE.get(de.getLocalizedMessage())); |
| | | } |
| | | |
| | | try |
| | | { |
| | | ldifWriter.writeEntry(entry); |
| | | ldifWriter.flush(); |
| | | } |
| | | catch (IOException ioe) |
| | | catch (final IOException ioe) |
| | | { |
| | | // Something is seriously wrong |
| | | throw new RuntimeException(ioe); |
| | | } |
| | | return true; |
| | | } |
| | | |
| | | |
| | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public void handleReference(SearchResultReference reference) |
| | | public boolean handleReference(final SearchResultReference reference) |
| | | { |
| | | println(LocalizableMessage.raw(reference.toString())); |
| | | return true; |
| | | } |
| | | } |
| | | |
| | |
| | | * The command-line arguments provided to this program. |
| | | */ |
| | | |
| | | public static void main(String[] args) |
| | | public static void main(final String[] args) |
| | | { |
| | | int retCode = mainSearch(args, false, System.in, System.out, |
| | | final int retCode = mainSearch(args, false, System.in, System.out, |
| | | System.err); |
| | | System.exit(filterExitCode(retCode)); |
| | | } |
| | |
| | | |
| | | |
| | | /** |
| | | * Parses the provided command-line arguments and uses that |
| | | * information to run the ldapsearch tool. |
| | | * Parses the provided command-line arguments and uses that information to run |
| | | * the ldapsearch tool. |
| | | * |
| | | * @param args |
| | | * The command-line arguments provided to this program. |
| | | * @return The error code. |
| | | */ |
| | | |
| | | static int mainSearch(String[] args) |
| | | static int mainSearch(final String[] args) |
| | | { |
| | | return mainSearch(args, true, System.in, System.out, System.err); |
| | | } |
| | |
| | | |
| | | |
| | | /** |
| | | * Parses the provided command-line arguments and uses that |
| | | * information to run the ldapsearch tool. |
| | | * |
| | | * @param args |
| | | * The command-line arguments provided to this program. |
| | | * @param inStream |
| | | * The input stream to use for standard input, or |
| | | * <CODE>null</CODE> if standard input is not needed. |
| | | * @param outStream |
| | | * The output stream to use for standard output, or |
| | | * <CODE>null</CODE> if standard output is not needed. |
| | | * @param errStream |
| | | * The output stream to use for standard error, or |
| | | * <CODE>null</CODE> if standard error is not needed. |
| | | * @return The error code. |
| | | */ |
| | | static int mainSearch(String[] args, InputStream inStream, |
| | | OutputStream outStream, OutputStream errStream) |
| | | { |
| | | return mainSearch(args, true, inStream, outStream, errStream); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Parses the provided command-line arguments and uses that |
| | | * information to run the ldapsearch tool. |
| | | * Parses the provided command-line arguments and uses that information to run |
| | | * the ldapsearch tool. |
| | | * |
| | | * @param args |
| | | * The command-line arguments provided to this program. |
| | | * @param returnMatchingEntries |
| | | * whether when the option --countEntries is specified, the |
| | | * number of matching entries should be returned or not. |
| | | * whether when the option --countEntries is specified, the number of |
| | | * matching entries should be returned or not. |
| | | * @param inStream |
| | | * The input stream to use for standard input, or |
| | | * <CODE>null</CODE> if standard input is not needed. |
| | | * The input stream to use for standard input, or <CODE>null</CODE> |
| | | * if standard input is not needed. |
| | | * @param outStream |
| | | * The output stream to use for standard output, or |
| | | * <CODE>null</CODE> if standard output is not needed. |
| | | * The output stream to use for standard output, or <CODE>null</CODE> |
| | | * if standard output is not needed. |
| | | * @param errStream |
| | | * The output stream to use for standard error, or |
| | | * <CODE>null</CODE> if standard error is not needed. |
| | | * The output stream to use for standard error, or <CODE>null</CODE> |
| | | * if standard error is not needed. |
| | | * @return The error code. |
| | | */ |
| | | |
| | | static int mainSearch(String[] args, |
| | | boolean returnMatchingEntries, InputStream inStream, |
| | | OutputStream outStream, OutputStream errStream) |
| | | static int mainSearch(final String[] args, |
| | | final boolean returnMatchingEntries, final InputStream inStream, |
| | | final OutputStream outStream, final OutputStream errStream) |
| | | { |
| | | return new LDAPSearch(inStream, outStream, errStream).run(args, |
| | | returnMatchingEntries); |
| | |
| | | |
| | | |
| | | |
| | | private LDAPSearch(InputStream in, OutputStream out, OutputStream err) |
| | | /** |
| | | * Parses the provided command-line arguments and uses that information to run |
| | | * the ldapsearch tool. |
| | | * |
| | | * @param args |
| | | * The command-line arguments provided to this program. |
| | | * @param inStream |
| | | * The input stream to use for standard input, or <CODE>null</CODE> |
| | | * if standard input is not needed. |
| | | * @param outStream |
| | | * The output stream to use for standard output, or <CODE>null</CODE> |
| | | * if standard output is not needed. |
| | | * @param errStream |
| | | * The output stream to use for standard error, or <CODE>null</CODE> |
| | | * if standard error is not needed. |
| | | * @return The error code. |
| | | */ |
| | | static int mainSearch(final String[] args, final InputStream inStream, |
| | | final OutputStream outStream, final OutputStream errStream) |
| | | { |
| | | return mainSearch(args, true, inStream, outStream, errStream); |
| | | } |
| | | |
| | | |
| | | |
| | | private BooleanArgument verbose; |
| | | |
| | | private EntryWriter ldifWriter; |
| | | |
| | | |
| | | |
| | | private LDAPSearch(final InputStream in, final OutputStream out, |
| | | final OutputStream err) |
| | | { |
| | | super(in, out, err); |
| | | |
| | |
| | | |
| | | |
| | | |
| | | private int run(String[] args, boolean returnMatchingEntries) |
| | | /** |
| | | * Indicates whether or not the user has requested advanced mode. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested advanced mode. |
| | | */ |
| | | @Override |
| | | public boolean isAdvancedMode() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested interactive behavior. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested interactive |
| | | * behavior. |
| | | */ |
| | | @Override |
| | | public boolean isInteractive() |
| | | { |
| | | return true; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not this console application is running in its |
| | | * menu-driven mode. This can be used to dictate whether output should go to |
| | | * the error stream or not. In addition, it may also dictate whether or not |
| | | * sub-menus should display a cancel option as well as a quit option. |
| | | * |
| | | * @return Returns <code>true</code> if this console application is running in |
| | | * its menu-driven mode. |
| | | */ |
| | | @Override |
| | | public boolean isMenuDrivenMode() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested quiet output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested quiet output. |
| | | */ |
| | | @Override |
| | | public boolean isQuiet() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested script-friendly output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested script-friendly |
| | | * output. |
| | | */ |
| | | @Override |
| | | public boolean isScriptFriendly() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested verbose output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested verbose output. |
| | | */ |
| | | @Override |
| | | public boolean isVerbose() |
| | | { |
| | | return verbose.isPresent(); |
| | | } |
| | | |
| | | |
| | | |
| | | private int run(final String[] args, final boolean returnMatchingEntries) |
| | | { |
| | | // Create the command-line argument parser for use with this |
| | | // program. |
| | | LocalizableMessage toolDescription = INFO_LDAPSEARCH_TOOL_DESCRIPTION.get(); |
| | | ArgumentParser argParser = new ArgumentParser(LDAPSearch.class |
| | | final LocalizableMessage toolDescription = INFO_LDAPSEARCH_TOOL_DESCRIPTION |
| | | .get(); |
| | | final ArgumentParser argParser = new ArgumentParser(LDAPSearch.class |
| | | .getName(), toolDescription, false, true, 0, 0, |
| | | "[filter] [attributes ...]"); |
| | | ArgumentParserConnectionFactory connectionFactory; |
| | |
| | | IntegerArgument sizeLimit; |
| | | try |
| | | { |
| | | connectionFactory = new ArgumentParserConnectionFactory( |
| | | argParser, this); |
| | | StringArgument propertiesFileArgument = new StringArgument( |
| | | "propertiesFilePath", null, OPTION_LONG_PROP_FILE_PATH, |
| | | false, false, true, INFO_PROP_FILE_PATH_PLACEHOLDER.get(), |
| | | null, null, INFO_DESCRIPTION_PROP_FILE_PATH.get()); |
| | | connectionFactory = new ArgumentParserConnectionFactory(argParser, this); |
| | | final StringArgument propertiesFileArgument = new StringArgument( |
| | | "propertiesFilePath", null, OPTION_LONG_PROP_FILE_PATH, false, false, |
| | | true, INFO_PROP_FILE_PATH_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_PROP_FILE_PATH.get()); |
| | | argParser.addArgument(propertiesFileArgument); |
| | | argParser.setFilePropertiesArgument(propertiesFileArgument); |
| | | |
| | | BooleanArgument noPropertiesFileArgument = new BooleanArgument( |
| | | final BooleanArgument noPropertiesFileArgument = new BooleanArgument( |
| | | "noPropertiesFileArgument", null, OPTION_LONG_NO_PROP_FILE, |
| | | INFO_DESCRIPTION_NO_PROP_FILE.get()); |
| | | argParser.addArgument(noPropertiesFileArgument); |
| | | argParser.setNoPropertiesFileArgument(noPropertiesFileArgument); |
| | | |
| | | baseDN = new StringArgument("baseDN", OPTION_SHORT_BASEDN, |
| | | OPTION_LONG_BASEDN, true, false, true, |
| | | INFO_BASEDN_PLACEHOLDER.get(), null, null, |
| | | INFO_SEARCH_DESCRIPTION_BASEDN.get()); |
| | | OPTION_LONG_BASEDN, true, false, true, INFO_BASEDN_PLACEHOLDER.get(), |
| | | null, null, INFO_SEARCH_DESCRIPTION_BASEDN.get()); |
| | | baseDN.setPropertyName(OPTION_LONG_BASEDN); |
| | | argParser.addArgument(baseDN); |
| | | |
| | | searchScope = new MultiChoiceArgument<SearchScope>("searchScope", |
| | | 's', "searchScope", false, true, |
| | | INFO_SEARCH_SCOPE_PLACEHOLDER.get(), SearchScope.values(), |
| | | false, INFO_SEARCH_DESCRIPTION_SEARCH_SCOPE.get()); |
| | | searchScope = new MultiChoiceArgument<SearchScope>("searchScope", 's', |
| | | "searchScope", false, true, INFO_SEARCH_SCOPE_PLACEHOLDER.get(), |
| | | SearchScope.values(), false, INFO_SEARCH_DESCRIPTION_SEARCH_SCOPE |
| | | .get()); |
| | | searchScope.setPropertyName("searchScope"); |
| | | searchScope.setDefaultValue(SearchScope.WHOLE_SUBTREE); |
| | | argParser.addArgument(searchScope); |
| | |
| | | argParser.addArgument(filename); |
| | | |
| | | proxyAuthzID = new StringArgument("proxy_authzid", |
| | | OPTION_SHORT_PROXYAUTHID, OPTION_LONG_PROXYAUTHID, false, |
| | | false, true, INFO_PROXYAUTHID_PLACEHOLDER.get(), null, null, |
| | | OPTION_SHORT_PROXYAUTHID, OPTION_LONG_PROXYAUTHID, false, false, |
| | | true, INFO_PROXYAUTHID_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_PROXY_AUTHZID.get()); |
| | | proxyAuthzID.setPropertyName(OPTION_LONG_PROXYAUTHID); |
| | | argParser.addArgument(proxyAuthzID); |
| | | |
| | | pSearchInfo = new StringArgument("psearchinfo", 'C', |
| | | "persistentSearch", false, false, true, |
| | | INFO_PSEARCH_PLACEHOLDER.get(), null, null, |
| | | pSearchInfo = new StringArgument("psearchinfo", 'C', "persistentSearch", |
| | | false, false, true, INFO_PSEARCH_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_PSEARCH_INFO.get()); |
| | | pSearchInfo.setPropertyName("persistentSearch"); |
| | | argParser.addArgument(pSearchInfo); |
| | | |
| | | simplePageSize = new IntegerArgument("simplepagesize", null, |
| | | "simplePageSize", false, false, true, |
| | | INFO_NUM_ENTRIES_PLACEHOLDER.get(), 1000, null, true, 1, |
| | | false, 0, INFO_DESCRIPTION_SIMPLE_PAGE_SIZE.get()); |
| | | "simplePageSize", false, false, true, INFO_NUM_ENTRIES_PLACEHOLDER |
| | | .get(), 1000, null, true, 1, false, 0, |
| | | INFO_DESCRIPTION_SIMPLE_PAGE_SIZE.get()); |
| | | simplePageSize.setPropertyName("simplePageSize"); |
| | | argParser.addArgument(simplePageSize); |
| | | |
| | |
| | | argParser.addArgument(assertionFilter); |
| | | |
| | | matchedValuesFilter = new StringArgument("matchedvalues", null, |
| | | "matchedValuesFilter", false, true, true, |
| | | INFO_FILTER_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_MATCHED_VALUES_FILTER.get()); |
| | | "matchedValuesFilter", false, true, true, INFO_FILTER_PLACEHOLDER |
| | | .get(), null, null, INFO_DESCRIPTION_MATCHED_VALUES_FILTER.get()); |
| | | matchedValuesFilter.setPropertyName("matchedValuesFilter"); |
| | | argParser.addArgument(matchedValuesFilter); |
| | | |
| | | sortOrder = new StringArgument("sortorder", 'S', "sortOrder", |
| | | false, false, true, INFO_SORT_ORDER_PLACEHOLDER.get(), null, |
| | | null, INFO_DESCRIPTION_SORT_ORDER.get()); |
| | | sortOrder = new StringArgument("sortorder", 'S', "sortOrder", false, |
| | | false, true, INFO_SORT_ORDER_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_SORT_ORDER.get()); |
| | | sortOrder.setPropertyName("sortOrder"); |
| | | argParser.addArgument(sortOrder); |
| | | |
| | | vlvDescriptor = new StringArgument("vlvdescriptor", 'G', |
| | | "virtualListView", false, false, true, INFO_VLV_PLACEHOLDER |
| | | .get(), null, null, INFO_DESCRIPTION_VLV.get()); |
| | | "virtualListView", false, false, true, INFO_VLV_PLACEHOLDER.get(), |
| | | null, null, INFO_DESCRIPTION_VLV.get()); |
| | | vlvDescriptor.setPropertyName("virtualListView"); |
| | | argParser.addArgument(vlvDescriptor); |
| | | |
| | | controlStr = new StringArgument("control", 'J', "control", false, |
| | | true, true, INFO_LDAP_CONTROL_PLACEHOLDER.get(), null, null, |
| | | controlStr = new StringArgument("control", 'J', "control", false, true, |
| | | true, INFO_LDAP_CONTROL_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_CONTROLS.get()); |
| | | controlStr.setPropertyName("control"); |
| | | argParser.addArgument(controlStr); |
| | | |
| | | effectiveRightsUser = new StringArgument("effectiveRightsUser", |
| | | OPTION_SHORT_EFFECTIVERIGHTSUSER, |
| | | OPTION_LONG_EFFECTIVERIGHTSUSER, false, false, true, |
| | | INFO_PROXYAUTHID_PLACEHOLDER.get(), null, null, |
| | | OPTION_SHORT_EFFECTIVERIGHTSUSER, OPTION_LONG_EFFECTIVERIGHTSUSER, |
| | | false, false, true, INFO_PROXYAUTHID_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_EFFECTIVERIGHTS_USER.get()); |
| | | effectiveRightsUser |
| | | .setPropertyName(OPTION_LONG_EFFECTIVERIGHTSUSER); |
| | | effectiveRightsUser.setPropertyName(OPTION_LONG_EFFECTIVERIGHTSUSER); |
| | | argParser.addArgument(effectiveRightsUser); |
| | | |
| | | effectiveRightsAttrs = new StringArgument("effectiveRightsAttrs", |
| | | OPTION_SHORT_EFFECTIVERIGHTSATTR, |
| | | OPTION_LONG_EFFECTIVERIGHTSATTR, false, true, true, |
| | | INFO_ATTRIBUTE_PLACEHOLDER.get(), null, null, |
| | | OPTION_SHORT_EFFECTIVERIGHTSATTR, OPTION_LONG_EFFECTIVERIGHTSATTR, |
| | | false, true, true, INFO_ATTRIBUTE_PLACEHOLDER.get(), null, null, |
| | | INFO_DESCRIPTION_EFFECTIVERIGHTS_ATTR.get()); |
| | | effectiveRightsAttrs |
| | | .setPropertyName(OPTION_LONG_EFFECTIVERIGHTSATTR); |
| | | effectiveRightsAttrs.setPropertyName(OPTION_LONG_EFFECTIVERIGHTSATTR); |
| | | argParser.addArgument(effectiveRightsAttrs); |
| | | |
| | | version = new IntegerArgument("version", |
| | | OPTION_SHORT_PROTOCOL_VERSION, OPTION_LONG_PROTOCOL_VERSION, |
| | | false, false, true, INFO_PROTOCOL_VERSION_PLACEHOLDER.get(), |
| | | 3, null, INFO_DESCRIPTION_VERSION.get()); |
| | | version = new IntegerArgument("version", OPTION_SHORT_PROTOCOL_VERSION, |
| | | OPTION_LONG_PROTOCOL_VERSION, false, false, true, |
| | | INFO_PROTOCOL_VERSION_PLACEHOLDER.get(), 3, null, |
| | | INFO_DESCRIPTION_VERSION.get()); |
| | | version.setPropertyName(OPTION_LONG_PROTOCOL_VERSION); |
| | | argParser.addArgument(version); |
| | | |
| | | StringArgument encodingStr = new StringArgument("encoding", 'i', |
| | | "encoding", false, false, true, INFO_ENCODING_PLACEHOLDER |
| | | .get(), null, null, INFO_DESCRIPTION_ENCODING.get()); |
| | | final StringArgument encodingStr = new StringArgument("encoding", 'i', |
| | | "encoding", false, false, true, INFO_ENCODING_PLACEHOLDER.get(), |
| | | null, null, INFO_DESCRIPTION_ENCODING.get()); |
| | | encodingStr.setPropertyName("encoding"); |
| | | argParser.addArgument(encodingStr); |
| | | |
| | | dereferencePolicy = new MultiChoiceArgument<DereferenceAliasesPolicy>( |
| | | "derefpolicy", 'a', "dereferencePolicy", false, true, |
| | | INFO_DEREFERENCE_POLICE_PLACEHOLDER.get(), |
| | | DereferenceAliasesPolicy.values(), false, |
| | | INFO_SEARCH_DESCRIPTION_DEREFERENCE_POLICY.get()); |
| | | INFO_DEREFERENCE_POLICE_PLACEHOLDER.get(), DereferenceAliasesPolicy |
| | | .values(), false, INFO_SEARCH_DESCRIPTION_DEREFERENCE_POLICY |
| | | .get()); |
| | | dereferencePolicy.setPropertyName("dereferencePolicy"); |
| | | dereferencePolicy.setDefaultValue(DereferenceAliasesPolicy.NEVER); |
| | | argParser.addArgument(dereferencePolicy); |
| | |
| | | typesOnly.setPropertyName("typesOnly"); |
| | | argParser.addArgument(typesOnly); |
| | | |
| | | sizeLimit = new IntegerArgument("sizeLimit", 'z', "sizeLimit", |
| | | false, false, true, INFO_SIZE_LIMIT_PLACEHOLDER.get(), 0, |
| | | null, INFO_SEARCH_DESCRIPTION_SIZE_LIMIT.get()); |
| | | sizeLimit = new IntegerArgument("sizeLimit", 'z', "sizeLimit", false, |
| | | false, true, INFO_SIZE_LIMIT_PLACEHOLDER.get(), 0, null, |
| | | INFO_SEARCH_DESCRIPTION_SIZE_LIMIT.get()); |
| | | sizeLimit.setPropertyName("sizeLimit"); |
| | | argParser.addArgument(sizeLimit); |
| | | |
| | | timeLimit = new IntegerArgument("timeLimit", 'l', "timeLimit", |
| | | false, false, true, INFO_TIME_LIMIT_PLACEHOLDER.get(), 0, |
| | | null, INFO_SEARCH_DESCRIPTION_TIME_LIMIT.get()); |
| | | timeLimit = new IntegerArgument("timeLimit", 'l', "timeLimit", false, |
| | | false, true, INFO_TIME_LIMIT_PLACEHOLDER.get(), 0, null, |
| | | INFO_SEARCH_DESCRIPTION_TIME_LIMIT.get()); |
| | | timeLimit.setPropertyName("timeLimit"); |
| | | argParser.addArgument(timeLimit); |
| | | |
| | |
| | | dontWrap.setPropertyName("dontWrap"); |
| | | argParser.addArgument(dontWrap); |
| | | |
| | | countEntries = new BooleanArgument("countentries", null, |
| | | "countEntries", INFO_DESCRIPTION_COUNT_ENTRIES.get()); |
| | | countEntries = new BooleanArgument("countentries", null, "countEntries", |
| | | INFO_DESCRIPTION_COUNT_ENTRIES.get()); |
| | | countEntries.setPropertyName("countEntries"); |
| | | argParser.addArgument(countEntries); |
| | | |
| | | BooleanArgument continueOnError = new BooleanArgument( |
| | | final BooleanArgument continueOnError = new BooleanArgument( |
| | | "continueOnError", 'c', "continueOnError", |
| | | INFO_DESCRIPTION_CONTINUE_ON_ERROR.get()); |
| | | continueOnError.setPropertyName("continueOnError"); |
| | |
| | | verbose.setPropertyName("verbose"); |
| | | argParser.addArgument(verbose); |
| | | |
| | | BooleanArgument showUsage = new BooleanArgument("showUsage", |
| | | OPTION_SHORT_HELP, OPTION_LONG_HELP, |
| | | INFO_DESCRIPTION_SHOWUSAGE.get()); |
| | | final BooleanArgument showUsage = new BooleanArgument("showUsage", |
| | | OPTION_SHORT_HELP, OPTION_LONG_HELP, INFO_DESCRIPTION_SHOWUSAGE.get()); |
| | | argParser.addArgument(showUsage); |
| | | argParser.setUsageArgument(showUsage, getOutputStream()); |
| | | } |
| | | catch (ArgumentException ae) |
| | | catch (final ArgumentException ae) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_INITIALIZE_ARGS.get(ae.getMessage()); |
| | | final LocalizableMessage message = ERR_CANNOT_INITIALIZE_ARGS.get(ae |
| | | .getMessage()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | argParser.parseArguments(args); |
| | | connectionFactory.validate(); |
| | | } |
| | | catch (ArgumentException ae) |
| | | catch (final ArgumentException ae) |
| | | { |
| | | LocalizableMessage message = ERR_ERROR_PARSING_ARGS.get(ae.getMessage()); |
| | | final LocalizableMessage message = ERR_ERROR_PARSING_ARGS.get(ae |
| | | .getMessage()); |
| | | println(message); |
| | | println(argParser.getUsageMessage()); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | return 0; |
| | | } |
| | | |
| | | List<Filter> filters = new LinkedList<Filter>(); |
| | | List<String> attributes = new LinkedList<String>(); |
| | | ArrayList<String> filterAndAttributeStrings = argParser |
| | | final List<Filter> filters = new LinkedList<Filter>(); |
| | | final List<String> attributes = new LinkedList<String>(); |
| | | final ArrayList<String> filterAndAttributeStrings = argParser |
| | | .getTrailingArguments(); |
| | | if (filterAndAttributeStrings.size() > 0) |
| | | { |
| | |
| | | // considered the filter, the other as attributes. |
| | | if (!filename.isPresent()) |
| | | { |
| | | String filterString = filterAndAttributeStrings.remove(0); |
| | | final String filterString = filterAndAttributeStrings.remove(0); |
| | | |
| | | try |
| | | { |
| | | filters.add(Filter.valueOf(filterString)); |
| | | } |
| | | catch (LocalizedIllegalArgumentException e) |
| | | catch (final LocalizedIllegalArgumentException e) |
| | | { |
| | | println(e.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_FILTER_ERROR.intValue(); |
| | | } |
| | | } |
| | | // The rest are attributes |
| | | for (String s : filterAndAttributeStrings) |
| | | for (final String s : filterAndAttributeStrings) |
| | | { |
| | | attributes.add(s); |
| | | } |
| | |
| | | // ignore empty lines. |
| | | continue; |
| | | } |
| | | Filter ldapFilter = Filter.valueOf(line); |
| | | final Filter ldapFilter = Filter.valueOf(line); |
| | | filters.add(ldapFilter); |
| | | } |
| | | } |
| | | catch (LocalizedIllegalArgumentException e) |
| | | catch (final LocalizedIllegalArgumentException e) |
| | | { |
| | | println(e.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_FILTER_ERROR.intValue(); |
| | | } |
| | | catch (IOException e) |
| | | catch (final IOException e) |
| | | { |
| | | println(LocalizableMessage.raw(e.toString())); |
| | | return ResultCode.CLIENT_SIDE_FILTER_ERROR.intValue(); |
| | |
| | | { |
| | | in.close(); |
| | | } |
| | | catch (IOException ioe) |
| | | catch (final IOException ioe) |
| | | { |
| | | } |
| | | } |
| | |
| | | { |
| | | scope = searchScope.getTypedValue(); |
| | | } |
| | | catch (ArgumentException ex1) |
| | | catch (final ArgumentException ex1) |
| | | { |
| | | println(ex1.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | SearchRequest search; |
| | | try |
| | | { |
| | | search = Requests.newSearchRequest(DN.valueOf(baseDN.getValue()), scope, filters.get(0), |
| | | attributes.toArray(new String[attributes |
| | | .size()])); |
| | | search = Requests.newSearchRequest(DN.valueOf(baseDN.getValue()), scope, |
| | | filters.get(0), attributes.toArray(new String[attributes.size()])); |
| | | } |
| | | catch (LocalizedIllegalArgumentException e) |
| | | catch (final LocalizedIllegalArgumentException e) |
| | | { |
| | | println(e.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | // Read the LDAP version number. |
| | | try |
| | | { |
| | | int versionNumber = version.getIntValue(); |
| | | final int versionNumber = version.getIntValue(); |
| | | if (versionNumber != 2 && versionNumber != 3) |
| | | { |
| | | println(ERR_DESCRIPTION_INVALID_VERSION.get(String |
| | |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | catch (ArgumentException ae) |
| | | catch (final ArgumentException ae) |
| | | { |
| | | println(ERR_DESCRIPTION_INVALID_VERSION.get(String |
| | | .valueOf(version.getValue()))); |
| | | println(ERR_DESCRIPTION_INVALID_VERSION.get(String.valueOf(version |
| | | .getValue()))); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | |
| | |
| | | search.setTimeLimit(timeLimit.getIntValue()); |
| | | search.setSizeLimit(sizeLimit.getIntValue()); |
| | | } |
| | | catch (ArgumentException ex1) |
| | | catch (final ArgumentException ex1) |
| | | { |
| | | println(ex1.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | try |
| | | { |
| | | search.setDereferenceAliasesPolicy(dereferencePolicy |
| | | .getTypedValue()); |
| | | search.setDereferenceAliasesPolicy(dereferencePolicy.getTypedValue()); |
| | | } |
| | | catch (ArgumentException ex1) |
| | | catch (final ArgumentException ex1) |
| | | { |
| | | println(ex1.getMessageObject()); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | |
| | | if (controlStr.isPresent()) |
| | | { |
| | | for (String ctrlString : controlStr.getValues()) |
| | | for (final String ctrlString : controlStr.getValues()) |
| | | { |
| | | try |
| | | { |
| | | Control ctrl = Utils.getControl(ctrlString); |
| | | final Control ctrl = Utils.getControl(ctrlString); |
| | | search.addControl(ctrl); |
| | | } |
| | | catch (DecodeException de) |
| | | catch (final DecodeException de) |
| | | { |
| | | LocalizableMessage message = ERR_TOOL_INVALID_CONTROL_STRING |
| | | final LocalizableMessage message = ERR_TOOL_INVALID_CONTROL_STRING |
| | | .get(ctrlString); |
| | | println(message); |
| | | ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | |
| | | if (effectiveRightsUser.isPresent()) |
| | | { |
| | | String authzID = effectiveRightsUser.getValue(); |
| | | final String authzID = effectiveRightsUser.getValue(); |
| | | if (!authzID.startsWith("dn:")) |
| | | { |
| | | LocalizableMessage message = ERR_EFFECTIVERIGHTS_INVALID_AUTHZID |
| | | final LocalizableMessage message = ERR_EFFECTIVERIGHTS_INVALID_AUTHZID |
| | | .get(authzID); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | Control effectiveRightsControl = new GetEffectiveRightsRequestControl( |
| | | false, authzID.substring(3), effectiveRightsAttrs.getValues() |
| | | .toArray( |
| | | final Control effectiveRightsControl = GetEffectiveRightsRequestControl |
| | | .newControl(false, authzID.substring(3), effectiveRightsAttrs |
| | | .getValues().toArray( |
| | | new String[effectiveRightsAttrs.getValues().size()])); |
| | | search.addControl(effectiveRightsControl); |
| | | } |
| | | |
| | | if (proxyAuthzID.isPresent()) |
| | | { |
| | | Control proxyControl = new ProxiedAuthV2Control(proxyAuthzID |
| | | .getValue()); |
| | | final Control proxyControl = ProxiedAuthV2RequestControl |
| | | .newControl(proxyAuthzID.getValue()); |
| | | search.addControl(proxyControl); |
| | | } |
| | | |
| | | if (pSearchInfo.isPresent()) |
| | | { |
| | | String infoString = StaticUtils.toLowerCase(pSearchInfo |
| | | .getValue().trim()); |
| | | final String infoString = StaticUtils.toLowerCase(pSearchInfo.getValue() |
| | | .trim()); |
| | | boolean changesOnly = true; |
| | | boolean returnECs = true; |
| | | |
| | | StringTokenizer tokenizer = new StringTokenizer(infoString, ":"); |
| | | final StringTokenizer tokenizer = new StringTokenizer(infoString, ":"); |
| | | |
| | | if (!tokenizer.hasMoreTokens()) |
| | | { |
| | | LocalizableMessage message = ERR_PSEARCH_MISSING_DESCRIPTOR.get(); |
| | | final LocalizableMessage message = ERR_PSEARCH_MISSING_DESCRIPTOR.get(); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | else |
| | | { |
| | | String token = tokenizer.nextToken(); |
| | | final String token = tokenizer.nextToken(); |
| | | if (!token.equals("ps")) |
| | | { |
| | | LocalizableMessage message = ERR_PSEARCH_DOESNT_START_WITH_PS.get(String |
| | | .valueOf(infoString)); |
| | | final LocalizableMessage message = ERR_PSEARCH_DOESNT_START_WITH_PS |
| | | .get(String.valueOf(infoString)); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | |
| | | ArrayList<PersistentSearchChangeType> ct = new ArrayList<PersistentSearchChangeType>( |
| | | final ArrayList<PersistentSearchChangeType> ct = new ArrayList<PersistentSearchChangeType>( |
| | | 4); |
| | | if (tokenizer.hasMoreTokens()) |
| | | { |
| | | StringTokenizer st = new StringTokenizer(tokenizer.nextToken(), |
| | | final StringTokenizer st = new StringTokenizer(tokenizer.nextToken(), |
| | | ", "); |
| | | if (!st.hasMoreTokens()) |
| | | { |
| | |
| | | ct.add(PersistentSearchChangeType.MODIFY_DN); |
| | | } |
| | | else |
| | | { |
| | | do |
| | | { |
| | | String token = st.nextToken(); |
| | | final String token = st.nextToken(); |
| | | if (token.equals("add")) |
| | | { |
| | | ct.add(PersistentSearchChangeType.ADD); |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_PSEARCH_INVALID_CHANGE_TYPE |
| | | final LocalizableMessage message = ERR_PSEARCH_INVALID_CHANGE_TYPE |
| | | .get(String.valueOf(token)); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } while (st.hasMoreTokens()); |
| | | } |
| | | while (st.hasMoreTokens()); |
| | | } |
| | | } |
| | | |
| | | if (tokenizer.hasMoreTokens()) |
| | | { |
| | | String token = tokenizer.nextToken(); |
| | | if (token.equals("1") || token.equals("true") |
| | | || token.equals("yes")) |
| | | final String token = tokenizer.nextToken(); |
| | | if (token.equals("1") || token.equals("true") || token.equals("yes")) |
| | | { |
| | | changesOnly = true; |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_PSEARCH_INVALID_CHANGESONLY.get(String |
| | | .valueOf(token)); |
| | | final LocalizableMessage message = ERR_PSEARCH_INVALID_CHANGESONLY |
| | | .get(String.valueOf(token)); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | |
| | | if (tokenizer.hasMoreTokens()) |
| | | { |
| | | String token = tokenizer.nextToken(); |
| | | if (token.equals("1") || token.equals("true") |
| | | || token.equals("yes")) |
| | | final String token = tokenizer.nextToken(); |
| | | if (token.equals("1") || token.equals("true") || token.equals("yes")) |
| | | { |
| | | returnECs = true; |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_PSEARCH_INVALID_RETURN_ECS.get(String |
| | | .valueOf(token)); |
| | | final LocalizableMessage message = ERR_PSEARCH_INVALID_RETURN_ECS |
| | | .get(String.valueOf(token)); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | |
| | | PersistentSearchControl psearchControl = new PersistentSearchControl( |
| | | changesOnly, returnECs, ct |
| | | final PersistentSearchRequestControl psearchControl = PersistentSearchRequestControl |
| | | .newControl(true, changesOnly, returnECs, ct |
| | | .toArray(new PersistentSearchChangeType[ct.size()])); |
| | | search.addControl(psearchControl); |
| | | } |
| | | |
| | | if (assertionFilter.isPresent()) |
| | | { |
| | | String filterString = assertionFilter.getValue(); |
| | | final String filterString = assertionFilter.getValue(); |
| | | Filter filter; |
| | | try |
| | | { |
| | |
| | | |
| | | // FIXME -- Change this to the correct OID when the official one |
| | | // is assigned. |
| | | Control assertionControl = new AssertionControl(true, filter); |
| | | final Control assertionControl = AssertionRequestControl.newControl( |
| | | true, filter); |
| | | search.addControl(assertionControl); |
| | | } |
| | | catch (LocalizedIllegalArgumentException le) |
| | | catch (final LocalizedIllegalArgumentException le) |
| | | { |
| | | LocalizableMessage message = ERR_LDAP_ASSERTION_INVALID_FILTER.get(le |
| | | .getMessage()); |
| | | final LocalizableMessage message = ERR_LDAP_ASSERTION_INVALID_FILTER |
| | | .get(le.getMessage()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | |
| | | if (matchedValuesFilter.isPresent()) |
| | | { |
| | | LinkedList<String> mvFilterStrings = matchedValuesFilter |
| | | final LinkedList<String> mvFilterStrings = matchedValuesFilter |
| | | .getValues(); |
| | | List<Filter> mvFilters = new ArrayList<Filter>(); |
| | | for (String s : mvFilterStrings) |
| | | final List<Filter> mvFilters = new ArrayList<Filter>(); |
| | | for (final String s : mvFilterStrings) |
| | | { |
| | | try |
| | | { |
| | | Filter f = Filter.valueOf(s); |
| | | final Filter f = Filter.valueOf(s); |
| | | mvFilters.add(f); |
| | | } |
| | | catch (LocalizedIllegalArgumentException le) |
| | | catch (final LocalizedIllegalArgumentException le) |
| | | { |
| | | LocalizableMessage message = ERR_LDAP_MATCHEDVALUES_INVALID_FILTER |
| | | final LocalizableMessage message = ERR_LDAP_MATCHEDVALUES_INVALID_FILTER |
| | | .get(le.getMessage()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | |
| | | MatchedValuesControl mvc = new MatchedValuesControl(true, |
| | | mvFilters.toArray(new Filter[mvFilters.size()])); |
| | | final MatchedValuesRequestControl mvc = MatchedValuesRequestControl |
| | | .newControl(true, mvFilters); |
| | | search.addControl(mvc); |
| | | } |
| | | |
| | |
| | | { |
| | | try |
| | | { |
| | | search.addControl(new ServerSideSortControl.Request(false, |
| | | search.addControl(ServerSideSortRequestControl.newControl(false, |
| | | sortOrder.getValue())); |
| | | } |
| | | catch (DecodeException le) |
| | | catch (final LocalizedIllegalArgumentException le) |
| | | { |
| | | LocalizableMessage message = ERR_LDAP_SORTCONTROL_INVALID_ORDER.get(le |
| | | .getMessageObject()); |
| | | final LocalizableMessage message = ERR_LDAP_SORTCONTROL_INVALID_ORDER |
| | | .get(le.getMessageObject()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | { |
| | | if (!sortOrder.isPresent()) |
| | | { |
| | | LocalizableMessage message = ERR_LDAPSEARCH_VLV_REQUIRES_SORT.get( |
| | | vlvDescriptor.getLongIdentifier(), sortOrder |
| | | final LocalizableMessage message = ERR_LDAPSEARCH_VLV_REQUIRES_SORT |
| | | .get(vlvDescriptor.getLongIdentifier(), sortOrder |
| | | .getLongIdentifier()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | |
| | | StringTokenizer tokenizer = new StringTokenizer(vlvDescriptor |
| | | final StringTokenizer tokenizer = new StringTokenizer(vlvDescriptor |
| | | .getValue(), ":"); |
| | | int numTokens = tokenizer.countTokens(); |
| | | final int numTokens = tokenizer.countTokens(); |
| | | if (numTokens == 3) |
| | | { |
| | | try |
| | | { |
| | | int beforeCount = Integer.parseInt(tokenizer.nextToken()); |
| | | int afterCount = Integer.parseInt(tokenizer.nextToken()); |
| | | ByteString assertionValue = ByteString.valueOf(tokenizer |
| | | final int beforeCount = Integer.parseInt(tokenizer.nextToken()); |
| | | final int afterCount = Integer.parseInt(tokenizer.nextToken()); |
| | | final ByteString assertionValue = ByteString.valueOf(tokenizer |
| | | .nextToken()); |
| | | search.addControl(new VLVControl.Request(beforeCount, |
| | | afterCount, assertionValue)); |
| | | search.addControl(VirtualListViewRequestControl.newAssertionControl( |
| | | true, assertionValue, beforeCount, afterCount, null)); |
| | | } |
| | | catch (Exception e) |
| | | catch (final Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR.get(); |
| | | final LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR |
| | | .get(); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | { |
| | | try |
| | | { |
| | | int beforeCount = Integer.parseInt(tokenizer.nextToken()); |
| | | int afterCount = Integer.parseInt(tokenizer.nextToken()); |
| | | int offset = Integer.parseInt(tokenizer.nextToken()); |
| | | int contentCount = Integer.parseInt(tokenizer.nextToken()); |
| | | search.addControl(new VLVControl.Request(beforeCount, |
| | | afterCount, offset, contentCount)); |
| | | final int beforeCount = Integer.parseInt(tokenizer.nextToken()); |
| | | final int afterCount = Integer.parseInt(tokenizer.nextToken()); |
| | | final int offset = Integer.parseInt(tokenizer.nextToken()); |
| | | final int contentCount = Integer.parseInt(tokenizer.nextToken()); |
| | | search.addControl(VirtualListViewRequestControl.newOffsetControl( |
| | | true, offset, contentCount, beforeCount, afterCount, null)); |
| | | } |
| | | catch (Exception e) |
| | | catch (final Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR.get(); |
| | | final LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR |
| | | .get(); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR.get(); |
| | | final LocalizableMessage message = ERR_LDAPSEARCH_VLV_INVALID_DESCRIPTOR |
| | | .get(); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | |
| | | { |
| | | if (filters.size() > 1) |
| | | { |
| | | LocalizableMessage message = ERR_PAGED_RESULTS_REQUIRES_SINGLE_FILTER |
| | | final LocalizableMessage message = ERR_PAGED_RESULTS_REQUIRES_SINGLE_FILTER |
| | | .get(); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | |
| | | try |
| | | { |
| | | pageSize = simplePageSize.getIntValue(); |
| | | search.addControl(new PagedResultsControl(pageSize, ByteString |
| | | .empty())); |
| | | search.addControl(SimplePagedResultsControl.newControl(true, pageSize, |
| | | ByteString.empty())); |
| | | } |
| | | catch (ArgumentException ae) |
| | | catch (final ArgumentException ae) |
| | | { |
| | | LocalizableMessage message = ERR_ERROR_PARSING_ARGS.get(ae.getMessage()); |
| | | final LocalizableMessage message = ERR_ERROR_PARSING_ARGS.get(ae |
| | | .getMessage()); |
| | | println(message); |
| | | return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue(); |
| | | } |
| | | } |
| | | /* |
| | | * if(connectionOptions.useSASLExternal()) { |
| | | * if(!connectionOptions.useSSL() && |
| | | * !connectionOptions.useStartTLS()) { LocalizableMessage message = |
| | | * if(connectionOptions.useSASLExternal()) { if(!connectionOptions.useSSL() |
| | | * && !connectionOptions.useStartTLS()) { LocalizableMessage message = |
| | | * ERR_TOOL_SASLEXTERNAL_NEEDS_SSL_OR_TLS.get(); |
| | | * err.println(wrapText(message, MAX_LINE_WIDTH)); return |
| | | * CLIENT_SIDE_PARAM_ERROR; } if(keyStorePathValue == null) { |
| | |
| | | if (noop.isPresent()) |
| | | { |
| | | // We don't actually need to open a connection or perform the |
| | | // search, |
| | | // so we're done. We should return 0 to either mean that the |
| | | // processing |
| | | // was successful or that there were no matching entries, based on |
| | | // countEntries.isPresent() (but in either case the return value |
| | | // should |
| | | // search, so we're done. We should return 0 to either mean that the |
| | | // processing was successful or that there were no matching entries, based |
| | | // on countEntries.isPresent() (but in either case the return value should |
| | | // be zero). |
| | | return 0; |
| | | } |
| | |
| | | { |
| | | connection = connectionFactory.getConnection(); |
| | | } |
| | | catch (ErrorResultException ere) |
| | | catch (final ErrorResultException ere) |
| | | { |
| | | return Utils.printErrorMessage(this, ere); |
| | | } |
| | | catch (final InterruptedException e) |
| | | { |
| | | // This shouldn't happen because there are no other threads to |
| | | // interrupt this one. |
| | | println(LocalizableMessage.raw(e.getLocalizedMessage())); |
| | | return ResultCode.CLIENT_SIDE_USER_CANCELLED.intValue(); |
| | | } |
| | | |
| | | Utils.printPasswordPolicyResults(this, connection); |
| | | |
| | |
| | | int filterIndex = 0; |
| | | ldifWriter = new LDIFEntryWriter(getOutputStream()) |
| | | .setWrapColumn(wrapColumn); |
| | | LDAPSearchResultHandler resultHandler = new LDAPSearchResultHandler(); |
| | | final LDAPSearchResultHandler resultHandler = new LDAPSearchResultHandler(); |
| | | while (true) |
| | | { |
| | | Result result; |
| | |
| | | { |
| | | result = connection.search(search, resultHandler); |
| | | } |
| | | catch (InterruptedException e) |
| | | catch (final InterruptedException e) |
| | | { |
| | | // This shouldn't happen because there are no other threads to |
| | | // interrupt this one. |
| | | result = Responses.newResult( |
| | | ResultCode.CLIENT_SIDE_USER_CANCELLED).setCause(e) |
| | | .setDiagnosticMessage(e.getLocalizedMessage()); |
| | | result = Responses.newResult(ResultCode.CLIENT_SIDE_USER_CANCELLED) |
| | | .setCause(e).setDiagnosticMessage(e.getLocalizedMessage()); |
| | | throw ErrorResultException.wrap(result); |
| | | } |
| | | |
| | | Control control = result |
| | | .getControl(ServerSideSortControl.OID_SERVER_SIDE_SORT_RESPONSE_CONTROL); |
| | | if (control != null |
| | | && control instanceof ServerSideSortControl.Response) |
| | | try |
| | | { |
| | | ServerSideSortControl.Response dc = (ServerSideSortControl.Response) control; |
| | | if (dc.getSortResult() != SortResult.SUCCESS) |
| | | final ServerSideSortResponseControl control = result.getControl( |
| | | ServerSideSortResponseControl.DECODER, new DecodeOptions()); |
| | | if (control != null) |
| | | { |
| | | LocalizableMessage msg = WARN_LDAPSEARCH_SORT_ERROR.get(dc |
| | | .getSortResult().toString()); |
| | | println(msg); |
| | | } |
| | | } |
| | | control = result |
| | | .getControl(VLVControl.OID_VLV_RESPONSE_CONTROL); |
| | | if (control != null && control instanceof VLVControl.Response) |
| | | { |
| | | VLVControl.Response dc = (VLVControl.Response) control; |
| | | if (dc.getVLVResult() == VLVResult.SUCCESS) |
| | | { |
| | | LocalizableMessage msg = INFO_LDAPSEARCH_VLV_TARGET_OFFSET.get(dc |
| | | .getTargetPosition()); |
| | | println(msg); |
| | | |
| | | msg = INFO_LDAPSEARCH_VLV_CONTENT_COUNT.get(dc |
| | | .getContentCount()); |
| | | println(msg); |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage msg = WARN_LDAPSEARCH_VLV_ERROR.get(dc |
| | | .getVLVResult().toString()); |
| | | println(msg); |
| | | } |
| | | } |
| | | |
| | | control = result |
| | | .getControl(PagedResultsControl.OID_PAGED_RESULTS_CONTROL); |
| | | if (control != null && control instanceof PagedResultsControl) |
| | | { |
| | | PagedResultsControl pagedControl = (PagedResultsControl) control; |
| | | if (pagedControl.getCookie().length() > 0) |
| | | { |
| | | if (!isQuiet()) |
| | | if (control.getResult() != ResultCode.SUCCESS) |
| | | { |
| | | pressReturnToContinue(); |
| | | final LocalizableMessage msg = WARN_LDAPSEARCH_SORT_ERROR |
| | | .get(control.getResult().toString()); |
| | | println(msg); |
| | | } |
| | | pagedControl = new PagedResultsControl(pageSize, |
| | | pagedControl.getCookie()); |
| | | search |
| | | .removeControl(PagedResultsControl.OID_PAGED_RESULTS_CONTROL); |
| | | search.addControl(pagedControl); |
| | | continue; |
| | | } |
| | | } |
| | | catch (final DecodeException e) |
| | | { |
| | | println(ERR_DECODE_CONTROL_FAILURE.get(e.getLocalizedMessage())); |
| | | } |
| | | |
| | | try |
| | | { |
| | | final VirtualListViewResponseControl control = result.getControl( |
| | | VirtualListViewResponseControl.DECODER, new DecodeOptions()); |
| | | if (control != null) |
| | | { |
| | | if (control.getResult() == ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage msg = INFO_LDAPSEARCH_VLV_TARGET_OFFSET |
| | | .get(control.getTargetPosition()); |
| | | println(msg); |
| | | |
| | | msg = INFO_LDAPSEARCH_VLV_CONTENT_COUNT.get(control |
| | | .getContentCount()); |
| | | println(msg); |
| | | } |
| | | else |
| | | { |
| | | final LocalizableMessage msg = WARN_LDAPSEARCH_VLV_ERROR |
| | | .get(control.getResult().toString()); |
| | | println(msg); |
| | | } |
| | | } |
| | | } |
| | | catch (final DecodeException e) |
| | | { |
| | | println(ERR_DECODE_CONTROL_FAILURE.get(e.getLocalizedMessage())); |
| | | } |
| | | |
| | | try |
| | | { |
| | | SimplePagedResultsControl control = result.getControl( |
| | | SimplePagedResultsControl.DECODER, new DecodeOptions()); |
| | | if (control != null) |
| | | { |
| | | if (control.getCookie().length() > 0) |
| | | { |
| | | if (!isQuiet()) |
| | | { |
| | | pressReturnToContinue(); |
| | | } |
| | | final Iterator<Control> iterator = search.getControls() |
| | | .iterator(); |
| | | while (iterator.hasNext()) |
| | | { |
| | | if (iterator.next().getOID().equals( |
| | | SimplePagedResultsControl.OID)) |
| | | { |
| | | iterator.remove(); |
| | | } |
| | | } |
| | | control = SimplePagedResultsControl.newControl(true, pageSize, |
| | | control.getCookie()); |
| | | search.addControl(control); |
| | | continue; |
| | | } |
| | | } |
| | | } |
| | | catch (final DecodeException e) |
| | | { |
| | | println(ERR_DECODE_CONTROL_FAILURE.get(e.getLocalizedMessage())); |
| | | } |
| | | |
| | | println(); |
| | | println(ERR_TOOL_RESULT_CODE.get(result.getResultCode() |
| | | .intValue(), result.getResultCode().toString())); |
| | | println(ERR_TOOL_RESULT_CODE.get(result.getResultCode().intValue(), |
| | | result.getResultCode().toString())); |
| | | if ((result.getDiagnosticMessage() != null) |
| | | && (result.getDiagnosticMessage().length() > 0)) |
| | | { |
| | | println(LocalizableMessage.raw(result.getDiagnosticMessage())); |
| | | } |
| | | if (result.getMatchedDN() != null |
| | | && result.getMatchedDN().length() > 0) |
| | | if (result.getMatchedDN() != null && result.getMatchedDN().length() > 0) |
| | | { |
| | | println(ERR_TOOL_MATCHED_DN.get(result.getMatchedDN())); |
| | | } |
| | |
| | | } |
| | | if (countEntries.isPresent() && !isQuiet()) |
| | | { |
| | | LocalizableMessage message = INFO_LDAPSEARCH_MATCHING_ENTRY_COUNT |
| | | final LocalizableMessage message = INFO_LDAPSEARCH_MATCHING_ENTRY_COUNT |
| | | .get(resultHandler.entryCount); |
| | | println(message); |
| | | println(); |
| | | } |
| | | } |
| | | catch (ErrorResultException ere) |
| | | catch (final ErrorResultException ere) |
| | | { |
| | | return Utils.printErrorMessage(this, ere); |
| | | } |
| | |
| | | |
| | | return 0; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested advanced mode. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested |
| | | * advanced mode. |
| | | */ |
| | | public boolean isAdvancedMode() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested interactive |
| | | * behavior. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested |
| | | * interactive behavior. |
| | | */ |
| | | public boolean isInteractive() |
| | | { |
| | | return true; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not this console application is running in its |
| | | * menu-driven mode. This can be used to dictate whether output should |
| | | * go to the error stream or not. In addition, it may also dictate |
| | | * whether or not sub-menus should display a cancel option as well as |
| | | * a quit option. |
| | | * |
| | | * @return Returns <code>true</code> if this console application is |
| | | * running in its menu-driven mode. |
| | | */ |
| | | public boolean isMenuDrivenMode() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested quiet output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested quiet |
| | | * output. |
| | | */ |
| | | public boolean isQuiet() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested script-friendly |
| | | * output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested |
| | | * script-friendly output. |
| | | */ |
| | | public boolean isScriptFriendly() |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether or not the user has requested verbose output. |
| | | * |
| | | * @return Returns <code>true</code> if the user has requested verbose |
| | | * output. |
| | | */ |
| | | public boolean isVerbose() |
| | | { |
| | | return verbose.isPresent(); |
| | | } |
| | | } |