1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
/* * @(#)SortControl.java 1.4 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.naming.ldap; import java.io.IOException; import com.sun.jndi.ldap.Ber; import com.sun.jndi.ldap.BerEncoder; /** * Requests that the results of a search operation be sorted by the LDAP server * before being returned. * The sort criteria are specified using an ordered list of one or more sort * keys, with associated sort parameters. * Search results are sorted at the LDAP server according to the parameters * supplied in the sort control and then returned to the requestor. If sorting * is not supported at the server (and the sort control is marked as critical) * then the search operation is not performed and an error is returned. * <p> * The following code sample shows how the class may be used: * <pre> * * // Open an LDAP association * LdapContext ctx = new InitialLdapContext(); * * // Activate sorting * String sortKey = "cn"; * ctx.setRequestControls(new Control[]{ * new SortControl(sortKey, Control.CRITICAL) }); * * // Perform a search * NamingEnumeration results = * ctx.search("", "(objectclass=*)", new SearchControls()); * * // Iterate over search results * while (results != null && results.hasMore()) { * // Display an entry * SearchResult entry = (SearchResult)results.next(); * System.out.println(entry.getName()); * System.out.println(entry.getAttributes()); * * // Handle the entry's response controls (if any) * if (entry instanceof HasControls) { * // ((HasControls)entry).getControls(); * } * } * // Examine the sort control response * Control[] controls = ctx.getResponseControls(); * if (controls != null) { * for (int i = 0; i < controls.length; i++) { * if (controls[i] instanceof SortResponseControl) { * SortResponseControl src = (SortResponseControl)controls[i]; * if (! src.isSorted()) { * throw src.getException(); * } * } else { * // Handle other response controls (if any) * } * } * } * * // Close the LDAP association * ctx.close(); * ... * * </pre> * <p> * This class implements the LDAPv3 Request Control for server-side sorting * as defined in * <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>. * * The control's value has the following ASN.1 definition: * <pre> * * SortKeyList ::= SEQUENCE OF SEQUENCE { * attributeType AttributeDescription, * orderingRule [0] MatchingRuleId OPTIONAL, * reverseOrder [1] BOOLEAN DEFAULT FALSE } * * </pre> * * @since 1.5 * @see SortKey * @see SortResponseControl * @author Vincent Ryan */ final public class SortControl extends BasicControl { /** * The server-side sort control's assigned object identifier * is 1.2.840.113556.1.4.473. */ public static final String OID = "1.2.840.113556.1.4.473"; private static final long serialVersionUID = -1965961680233330744L; /** * Constructs a control to sort on a single attribute in ascending order. * Sorting will be performed using the ordering matching rule defined * for use with the specified attribute. * * @param sortBy An attribute ID to sort by. * @param criticality If true then the server must honor the control * and return the search results sorted as * requested or refuse to perform the search. * If false, then the server need not honor the * control. * @exception IOException If an error was encountered while encoding the * supplied arguments into a control. */ public SortControl(String sortBy, boolean criticality) throws IOException { super(OID, criticality, null); super.value = setEncodedValue(new SortKey[]{ new SortKey(sortBy) }); } /** * Constructs a control to sort on a list of attributes in ascending order. * Sorting will be performed using the ordering matching rule defined * for use with each of the specified attributes. * * @param sortBy A non-null list of attribute IDs to sort by. * The list is in order of highest to lowest sort key * precedence. * @param criticality If true then the server must honor the control * and return the search results sorted as * requested or refuse to perform the search. * If false, then the server need not honor the * control. * @exception IOException If an error was encountered while encoding the * supplied arguments into a control. */ public SortControl(String[] sortBy, boolean criticality) throws IOException { super(OID, criticality, null); SortKey[] sortKeys = new SortKey[sortBy.length]; for (int i = 0; i < sortBy.length; i++) { sortKeys[i] = new SortKey(sortBy[i]); } super.value = setEncodedValue(sortKeys); } /** * Constructs a control to sort on a list of sort keys. * Each sort key specifies the sort order and ordering matching rule to use. * * @param sortBy A non-null list of keys to sort by. * The list is in order of highest to lowest sort key * precedence. * @param criticality If true then the server must honor the control * and return the search results sorted as * requested or refuse to perform the search. * If false, then the server need not honor the * control. * @exception IOException If an error was encountered while encoding the * supplied arguments into a control. */ public SortControl(SortKey[] sortBy, boolean criticality) throws IOException { super(OID, criticality, null); super.value = setEncodedValue(sortBy); } /* * Encodes the sort control's value using ASN.1 BER. * The result includes the BER tag and length for the control's value but * does not include the control's object identifer and criticality setting. * * @param sortKeys A non-null list of keys to sort by. * @return A possibly null byte array representing the ASN.1 BER encoded * value of the sort control. * @exception IOException If a BER encoding error occurs. */ private byte[] setEncodedValue(SortKey[] sortKeys) throws IOException { // build the ASN.1 BER encoding BerEncoder ber = new BerEncoder(30 * sortKeys.length + 10); String matchingRule; ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR); for (int i = 0; i < sortKeys.length; i++) { ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR); ber.encodeString(sortKeys[i].getAttributeID(), true); // v3 if ((matchingRule = sortKeys[i].getMatchingRuleID()) != null) { ber.encodeString(matchingRule, (Ber.ASN_CONTEXT | 0), true); } if (! sortKeys[i].isAscending()) { ber.encodeBoolean(true, (Ber.ASN_CONTEXT | 1)); } ber.endSeq(); } ber.endSeq(); return ber.getTrimmedBuf(); } }