| /* |
| * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package com.sun.jndi.toolkit.dir; |
| |
| import javax.naming.*; |
| import javax.naming.directory.*; |
| import java.util.Enumeration; |
| import java.util.StringTokenizer; |
| import java.util.Vector; |
| |
| /** |
| * A class for parsing LDAP search filters (defined in RFC 1960, 2254) |
| * |
| * @author Jon Ruiz |
| * @author Rosanna Lee |
| */ |
| public class SearchFilter implements AttrFilter { |
| |
| interface StringFilter extends AttrFilter { |
| public void parse() throws InvalidSearchFilterException; |
| } |
| |
| // %%% "filter" and "pos" are not declared "private" due to bug 4064984. |
| String filter; |
| int pos; |
| private StringFilter rootFilter; |
| |
| protected static final boolean debug = false; |
| |
| protected static final char BEGIN_FILTER_TOKEN = '('; |
| protected static final char END_FILTER_TOKEN = ')'; |
| protected static final char AND_TOKEN = '&'; |
| protected static final char OR_TOKEN = '|'; |
| protected static final char NOT_TOKEN = '!'; |
| protected static final char EQUAL_TOKEN = '='; |
| protected static final char APPROX_TOKEN = '~'; |
| protected static final char LESS_TOKEN = '<'; |
| protected static final char GREATER_TOKEN = '>'; |
| protected static final char EXTEND_TOKEN = ':'; |
| protected static final char WILDCARD_TOKEN = '*'; |
| |
| public SearchFilter(String filter) throws InvalidSearchFilterException { |
| this.filter = filter; |
| pos = 0; |
| normalizeFilter(); |
| rootFilter = this.createNextFilter(); |
| } |
| |
| // Returns true if targetAttrs passes the filter |
| public boolean check(Attributes targetAttrs) throws NamingException { |
| if (targetAttrs == null) |
| return false; |
| |
| return rootFilter.check(targetAttrs); |
| } |
| |
| /* |
| * Utility routines used by member classes |
| */ |
| |
| // does some pre-processing on the string to make it look exactly lik |
| // what the parser expects. This only needs to be called once. |
| protected void normalizeFilter() { |
| skipWhiteSpace(); // get rid of any leading whitespaces |
| |
| // Sometimes, search filters don't have "(" and ")" - add them |
| if(getCurrentChar() != BEGIN_FILTER_TOKEN) { |
| filter = BEGIN_FILTER_TOKEN + filter + END_FILTER_TOKEN; |
| } |
| // this would be a good place to strip whitespace if desired |
| |
| if(debug) {System.out.println("SearchFilter: normalized filter:" + |
| filter);} |
| } |
| |
| private void skipWhiteSpace() { |
| while (Character.isWhitespace(getCurrentChar())) { |
| consumeChar(); |
| } |
| } |
| |
| protected StringFilter createNextFilter() |
| throws InvalidSearchFilterException { |
| StringFilter filter; |
| |
| skipWhiteSpace(); |
| |
| try { |
| // make sure every filter starts with "(" |
| if(getCurrentChar() != BEGIN_FILTER_TOKEN) { |
| throw new InvalidSearchFilterException("expected \"" + |
| BEGIN_FILTER_TOKEN + |
| "\" at position " + |
| pos); |
| } |
| |
| // skip past the "(" |
| this.consumeChar(); |
| |
| skipWhiteSpace(); |
| |
| // use the next character to determine the type of filter |
| switch(getCurrentChar()) { |
| case AND_TOKEN: |
| if (debug) {System.out.println("SearchFilter: creating AND");} |
| filter = new CompoundFilter(true); |
| filter.parse(); |
| break; |
| case OR_TOKEN: |
| if (debug) {System.out.println("SearchFilter: creating OR");} |
| filter = new CompoundFilter(false); |
| filter.parse(); |
| break; |
| case NOT_TOKEN: |
| if (debug) {System.out.println("SearchFilter: creating OR");} |
| filter = new NotFilter(); |
| filter.parse(); |
| break; |
| default: |
| if (debug) {System.out.println("SearchFilter: creating SIMPLE");} |
| filter = new AtomicFilter(); |
| filter.parse(); |
| break; |
| } |
| |
| skipWhiteSpace(); |
| |
| // make sure every filter ends with ")" |
| if(getCurrentChar() != END_FILTER_TOKEN) { |
| throw new InvalidSearchFilterException("expected \"" + |
| END_FILTER_TOKEN + |
| "\" at position " + |
| pos); |
| } |
| |
| // skip past the ")" |
| this.consumeChar(); |
| } catch (InvalidSearchFilterException e) { |
| if (debug) {System.out.println("rethrowing e");} |
| throw e; // just rethrow these |
| |
| // catch all - any uncaught exception while parsing will end up here |
| } catch (Exception e) { |
| if(debug) {System.out.println(e.getMessage());e.printStackTrace();} |
| throw new InvalidSearchFilterException("Unable to parse " + |
| "character " + pos + " in \""+ |
| this.filter + "\""); |
| } |
| |
| return filter; |
| } |
| |
| protected char getCurrentChar() { |
| return filter.charAt(pos); |
| } |
| |
| protected char relCharAt(int i) { |
| return filter.charAt(pos + i); |
| } |
| |
| protected void consumeChar() { |
| pos++; |
| } |
| |
| protected void consumeChars(int i) { |
| pos += i; |
| } |
| |
| protected int relIndexOf(int ch) { |
| return filter.indexOf(ch, pos) - pos; |
| } |
| |
| protected String relSubstring(int beginIndex, int endIndex){ |
| if(debug){System.out.println("relSubString: " + beginIndex + |
| " " + endIndex);} |
| return filter.substring(beginIndex+pos, endIndex+pos); |
| } |
| |
| |
| /** |
| * A class for dealing with compound filters ("and" & "or" filters). |
| */ |
| final class CompoundFilter implements StringFilter { |
| private Vector subFilters; |
| private boolean polarity; |
| |
| CompoundFilter(boolean polarity) { |
| subFilters = new Vector(); |
| this.polarity = polarity; |
| } |
| |
| public void parse() throws InvalidSearchFilterException { |
| SearchFilter.this.consumeChar(); // consume the "&" |
| while(SearchFilter.this.getCurrentChar() != END_FILTER_TOKEN) { |
| if (debug) {System.out.println("CompoundFilter: adding");} |
| StringFilter filter = SearchFilter.this.createNextFilter(); |
| subFilters.addElement(filter); |
| skipWhiteSpace(); |
| } |
| } |
| |
| public boolean check(Attributes targetAttrs) throws NamingException { |
| for(int i = 0; i<subFilters.size(); i++) { |
| StringFilter filter = (StringFilter)subFilters.elementAt(i); |
| if(filter.check(targetAttrs) != this.polarity) { |
| return !polarity; |
| } |
| } |
| return polarity; |
| } |
| } /* CompoundFilter */ |
| |
| /** |
| * A class for dealing with NOT filters |
| */ |
| final class NotFilter implements StringFilter { |
| private StringFilter filter; |
| |
| public void parse() throws InvalidSearchFilterException { |
| SearchFilter.this.consumeChar(); // consume the "!" |
| filter = SearchFilter.this.createNextFilter(); |
| } |
| |
| public boolean check(Attributes targetAttrs) throws NamingException { |
| return !filter.check(targetAttrs); |
| } |
| } /* notFilter */ |
| |
| // note: declared here since member classes can't have static variables |
| static final int EQUAL_MATCH = 1; |
| static final int APPROX_MATCH = 2; |
| static final int GREATER_MATCH = 3; |
| static final int LESS_MATCH = 4; |
| |
| /** |
| * A class for dealing wtih atomic filters |
| */ |
| final class AtomicFilter implements StringFilter { |
| private String attrID; |
| private String value; |
| private int matchType; |
| |
| public void parse() throws InvalidSearchFilterException { |
| |
| skipWhiteSpace(); |
| |
| try { |
| // find the end |
| int endPos = SearchFilter.this.relIndexOf(END_FILTER_TOKEN); |
| |
| //determine the match type |
| int i = SearchFilter.this.relIndexOf(EQUAL_TOKEN); |
| if(debug) {System.out.println("AtomicFilter: = at " + i);} |
| int qualifier = SearchFilter.this.relCharAt(i-1); |
| switch(qualifier) { |
| case APPROX_TOKEN: |
| if (debug) {System.out.println("Atomic: APPROX found");} |
| matchType = APPROX_MATCH; |
| attrID = SearchFilter.this.relSubstring(0, i-1); |
| value = SearchFilter.this.relSubstring(i+1, endPos); |
| break; |
| |
| case GREATER_TOKEN: |
| if (debug) {System.out.println("Atomic: GREATER found");} |
| matchType = GREATER_MATCH; |
| attrID = SearchFilter.this.relSubstring(0, i-1); |
| value = SearchFilter.this.relSubstring(i+1, endPos); |
| break; |
| |
| case LESS_TOKEN: |
| if (debug) {System.out.println("Atomic: LESS found");} |
| matchType = LESS_MATCH; |
| attrID = SearchFilter.this.relSubstring(0, i-1); |
| value = SearchFilter.this.relSubstring(i+1, endPos); |
| break; |
| |
| case EXTEND_TOKEN: |
| if(debug) {System.out.println("Atomic: EXTEND found");} |
| throw new OperationNotSupportedException("Extensible match not supported"); |
| |
| default: |
| if (debug) {System.out.println("Atomic: EQUAL found");} |
| matchType = EQUAL_MATCH; |
| attrID = SearchFilter.this.relSubstring(0,i); |
| value = SearchFilter.this.relSubstring(i+1, endPos); |
| break; |
| } |
| |
| attrID = attrID.trim(); |
| value = value.trim(); |
| |
| //update our position |
| SearchFilter.this.consumeChars(endPos); |
| |
| } catch (Exception e) { |
| if (debug) {System.out.println(e.getMessage()); |
| e.printStackTrace();} |
| InvalidSearchFilterException sfe = |
| new InvalidSearchFilterException("Unable to parse " + |
| "character " + SearchFilter.this.pos + " in \""+ |
| SearchFilter.this.filter + "\""); |
| sfe.setRootCause(e); |
| throw(sfe); |
| } |
| |
| if(debug) {System.out.println("AtomicFilter: " + attrID + "=" + |
| value);} |
| } |
| |
| public boolean check(Attributes targetAttrs) { |
| Enumeration candidates; |
| |
| try { |
| Attribute attr = targetAttrs.get(attrID); |
| if(attr == null) { |
| return false; |
| } |
| candidates = attr.getAll(); |
| } catch (NamingException ne) { |
| if (debug) {System.out.println("AtomicFilter: should never " + |
| "here");} |
| return false; |
| } |
| |
| while(candidates.hasMoreElements()) { |
| String val = candidates.nextElement().toString(); |
| if (debug) {System.out.println("Atomic: comparing: " + val);} |
| switch(matchType) { |
| case APPROX_MATCH: |
| case EQUAL_MATCH: |
| if(substringMatch(this.value, val)) { |
| if (debug) {System.out.println("Atomic: EQUAL match");} |
| return true; |
| } |
| break; |
| case GREATER_MATCH: |
| if (debug) {System.out.println("Atomic: GREATER match");} |
| if(val.compareTo(this.value) >= 0) { |
| return true; |
| } |
| break; |
| case LESS_MATCH: |
| if (debug) {System.out.println("Atomic: LESS match");} |
| if(val.compareTo(this.value) <= 0) { |
| return true; |
| } |
| break; |
| default: |
| if (debug) {System.out.println("AtomicFilter: unkown " + |
| "matchType");} |
| } |
| } |
| return false; |
| } |
| |
| // used for substring comparisons (where proto has "*" wildcards |
| private boolean substringMatch(String proto, String value) { |
| // simple case 1: "*" means attribute presence is being tested |
| if(proto.equals(new Character(WILDCARD_TOKEN).toString())) { |
| if(debug) {System.out.println("simple presence assertion");} |
| return true; |
| } |
| |
| // simple case 2: if there are no wildcards, call String.equals() |
| if(proto.indexOf(WILDCARD_TOKEN) == -1) { |
| return proto.equalsIgnoreCase(value); |
| } |
| |
| if(debug) {System.out.println("doing substring comparison");} |
| // do the work: make sure all the substrings are present |
| int currentPos = 0; |
| StringTokenizer subStrs = new StringTokenizer(proto, "*", false); |
| |
| // do we need to begin with the first token? |
| if(proto.charAt(0) != WILDCARD_TOKEN && |
| !value.toString().toLowerCase().startsWith( |
| subStrs.nextToken().toLowerCase())) { |
| if(debug) {System.out.println("faild initial test");} |
| return false; |
| } |
| |
| |
| while(subStrs.hasMoreTokens()) { |
| String currentStr = subStrs.nextToken(); |
| if (debug) {System.out.println("looking for \"" + |
| currentStr +"\"");} |
| currentPos = value.toLowerCase().indexOf( |
| currentStr.toLowerCase(), currentPos); |
| if(currentPos == -1) { |
| return false; |
| } |
| currentPos += currentStr.length(); |
| } |
| |
| // do we need to end with the last token? |
| if(proto.charAt(proto.length() - 1) != WILDCARD_TOKEN && |
| currentPos != value.length() ) { |
| if(debug) {System.out.println("faild final test");} |
| return false; |
| } |
| |
| return true; |
| } |
| |
| } /* AtomicFilter */ |
| |
| // ----- static methods for producing string filters given attribute set |
| // ----- or object array |
| |
| |
| /** |
| * Creates an LDAP filter as a conjuction of the attributes supplied. |
| */ |
| public static String format(Attributes attrs) throws NamingException { |
| if (attrs == null || attrs.size() == 0) { |
| return "objectClass=*"; |
| } |
| |
| String answer; |
| answer = "(& "; |
| Attribute attr; |
| for (NamingEnumeration e = attrs.getAll(); e.hasMore(); ) { |
| attr = (Attribute)e.next(); |
| if (attr.size() == 0 || (attr.size() == 1 && attr.get() == null)) { |
| // only checking presence of attribute |
| answer += "(" + attr.getID() + "=" + "*)"; |
| } else { |
| for (NamingEnumeration ve = attr.getAll(); |
| ve.hasMore(); |
| ) { |
| String val = getEncodedStringRep(ve.next()); |
| if (val != null) { |
| answer += "(" + attr.getID() + "=" + val + ")"; |
| } |
| } |
| } |
| } |
| |
| answer += ")"; |
| //System.out.println("filter: " + answer); |
| return answer; |
| } |
| |
| // Writes the hex representation of a byte to a StringBuffer. |
| private static void hexDigit(StringBuffer buf, byte x) { |
| char c; |
| |
| c = (char) ((x >> 4) & 0xf); |
| if (c > 9) |
| c = (char) ((c-10) + 'A'); |
| else |
| c = (char)(c + '0'); |
| |
| buf.append(c); |
| c = (char) (x & 0xf); |
| if (c > 9) |
| c = (char)((c-10) + 'A'); |
| else |
| c = (char)(c + '0'); |
| buf.append(c); |
| } |
| |
| |
| /** |
| * Returns the string representation of an object (such as an attr value). |
| * If obj is a byte array, encode each item as \xx, where xx is hex encoding |
| * of the byte value. |
| * Else, if obj is not a String, use its string representation (toString()). |
| * Special characters in obj (or its string representation) are then |
| * encoded appropriately according to RFC 2254. |
| * * \2a |
| * ( \28 |
| * ) \29 |
| * \ \5c |
| * NUL \00 |
| */ |
| private static String getEncodedStringRep(Object obj) throws NamingException { |
| String str; |
| if (obj == null) |
| return null; |
| |
| if (obj instanceof byte[]) { |
| // binary data must be encoded as \hh where hh is a hex char |
| byte[] bytes = (byte[])obj; |
| StringBuffer b1 = new StringBuffer(bytes.length*3); |
| for (int i = 0; i < bytes.length; i++) { |
| b1.append('\\'); |
| hexDigit(b1, bytes[i]); |
| } |
| return b1.toString(); |
| } |
| if (!(obj instanceof String)) { |
| str = obj.toString(); |
| } else { |
| str = (String)obj; |
| } |
| int len = str.length(); |
| StringBuffer buf = new StringBuffer(len); |
| char ch; |
| for (int i = 0; i < len; i++) { |
| switch (ch=str.charAt(i)) { |
| case '*': |
| buf.append("\\2a"); |
| break; |
| case '(': |
| buf.append("\\28"); |
| break; |
| case ')': |
| buf.append("\\29"); |
| break; |
| case '\\': |
| buf.append("\\5c"); |
| break; |
| case 0: |
| buf.append("\\00"); |
| break; |
| default: |
| buf.append(ch); |
| } |
| } |
| return buf.toString(); |
| } |
| |
| |
| /** |
| * Finds the first occurrence of <tt>ch</tt> in <tt>val</tt> starting |
| * from position <tt>start</tt>. It doesn't count if <tt>ch</tt> |
| * has been escaped by a backslash (\) |
| */ |
| public static int findUnescaped(char ch, String val, int start) { |
| int len = val.length(); |
| |
| while (start < len) { |
| int where = val.indexOf(ch, start); |
| // if at start of string, or not there at all, or if not escaped |
| if (where == start || where == -1 || val.charAt(where-1) != '\\') |
| return where; |
| |
| // start search after escaped star |
| start = where + 1; |
| } |
| return -1; |
| } |
| |
| /** |
| * Formats the expression <tt>expr</tt> using arguments from the array |
| * <tt>args</tt>. |
| * |
| * <code>{i}</code> specifies the <code>i</code>'th element from |
| * the array <code>args</code> is to be substituted for the |
| * string "<code>{i}</code>". |
| * |
| * To escape '{' or '}' (or any other character), use '\'. |
| * |
| * Uses getEncodedStringRep() to do encoding. |
| */ |
| |
| public static String format(String expr, Object[] args) |
| throws NamingException { |
| |
| int param; |
| int where = 0, start = 0; |
| StringBuffer answer = new StringBuffer(expr.length()); |
| |
| while ((where = findUnescaped('{', expr, start)) >= 0) { |
| int pstart = where + 1; // skip '{' |
| int pend = expr.indexOf('}', pstart); |
| |
| if (pend < 0) { |
| throw new InvalidSearchFilterException("unbalanced {: " + expr); |
| } |
| |
| // at this point, pend should be pointing at '}' |
| try { |
| param = Integer.parseInt(expr.substring(pstart, pend)); |
| } catch (NumberFormatException e) { |
| throw new InvalidSearchFilterException( |
| "integer expected inside {}: " + expr); |
| } |
| |
| if (param >= args.length) { |
| throw new InvalidSearchFilterException( |
| "number exceeds argument list: " + param); |
| } |
| |
| answer.append(expr.substring(start, where)).append(getEncodedStringRep(args[param])); |
| start = pend + 1; // skip '}' |
| } |
| |
| if (start < expr.length()) |
| answer.append(expr.substring(start)); |
| |
| return answer.toString(); |
| } |
| |
| /* |
| * returns an Attributes instance containing only attributeIDs given in |
| * "attributeIDs" whose values come from the given DSContext. |
| */ |
| public static Attributes selectAttributes(Attributes originals, |
| String[] attrIDs) throws NamingException { |
| |
| if (attrIDs == null) |
| return originals; |
| |
| Attributes result = new BasicAttributes(); |
| |
| for(int i=0; i<attrIDs.length; i++) { |
| Attribute attr = originals.get(attrIDs[i]); |
| if(attr != null) { |
| result.put(attr); |
| } |
| } |
| |
| return result; |
| } |
| |
| /* For testing filter |
| public static void main(String[] args) { |
| |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| attrs.put("cn", "Rosanna Lee"); |
| attrs.put("sn", "Lee"); |
| attrs.put("fn", "Rosanna"); |
| attrs.put("id", "10414"); |
| attrs.put("machine", "jurassic"); |
| |
| |
| try { |
| System.out.println(format(attrs)); |
| |
| String expr = "(&(Age = {0})(Account Balance <= {1}))"; |
| Object[] fargs = new Object[2]; |
| // fill in the parameters |
| fargs[0] = new Integer(65); |
| fargs[1] = new Float(5000); |
| |
| System.out.println(format(expr, fargs)); |
| |
| |
| System.out.println(format("bin={0}", |
| new Object[] {new byte[] {0, 1, 2, 3, 4, 5}})); |
| |
| System.out.println(format("bin=\\{anything}", null)); |
| |
| } catch (NamingException e) { |
| e.printStackTrace(); |
| } |
| } |
| */ |
| |
| } |
