| /* |
| * Copyright (c) 1999, 2011, 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.ldap; |
| |
| import javax.naming.*; |
| import javax.naming.directory.*; |
| import java.util.Vector; |
| |
| /** |
| * Netscape's 3.1 servers have some schema bugs: |
| * - It puts quotes around OIDs (such as those for SUP, SYNTAX). |
| * - When you try to write out the MUST/MAY list (such as "MUST cn"), |
| * it wants ("MUST (cn)") instead |
| */ |
| |
| final class LdapSchemaParser { |
| |
| // do debugging |
| private static final boolean debug = false; |
| |
| |
| // names of attribute IDs in the LDAP schema entry |
| static final String OBJECTCLASSDESC_ATTR_ID = "objectClasses"; |
| static final String ATTRIBUTEDESC_ATTR_ID = "attributeTypes"; |
| static final String SYNTAXDESC_ATTR_ID = "ldapSyntaxes"; |
| static final String MATCHRULEDESC_ATTR_ID = "matchingRules"; |
| |
| // information for creating internal nodes in JNDI schema tree |
| static final String OBJECTCLASS_DEFINITION_NAME = |
| "ClassDefinition"; |
| private static final String[] CLASS_DEF_ATTRS = { |
| "objectclass", "ClassDefinition"}; |
| static final String ATTRIBUTE_DEFINITION_NAME = |
| "AttributeDefinition"; |
| private static final String[] ATTR_DEF_ATTRS = { |
| "objectclass", "AttributeDefinition" }; |
| static final String SYNTAX_DEFINITION_NAME = |
| "SyntaxDefinition"; |
| private static final String[] SYNTAX_DEF_ATTRS = { |
| "objectclass", "SyntaxDefinition" }; |
| static final String MATCHRULE_DEFINITION_NAME = |
| "MatchingRule"; |
| private static final String[] MATCHRULE_DEF_ATTRS = { |
| "objectclass", "MatchingRule" }; |
| |
| // special tokens used in LDAP schema descriptions |
| private static final char SINGLE_QUOTE = '\''; |
| private static final char WHSP = ' '; |
| private static final char OID_LIST_BEGIN = '('; |
| private static final char OID_LIST_END = ')'; |
| private static final char OID_SEPARATOR = '$'; |
| |
| // common IDs |
| private static final String NUMERICOID_ID = "NUMERICOID"; |
| private static final String NAME_ID = "NAME"; |
| private static final String DESC_ID = "DESC"; |
| private static final String OBSOLETE_ID = "OBSOLETE"; |
| private static final String SUP_ID = "SUP"; |
| private static final String PRIVATE_ID = "X-"; |
| |
| // Object Class specific IDs |
| private static final String ABSTRACT_ID = "ABSTRACT"; |
| private static final String STRUCTURAL_ID = "STRUCTURAL"; |
| private static final String AUXILARY_ID = "AUXILIARY"; |
| private static final String MUST_ID = "MUST"; |
| private static final String MAY_ID = "MAY"; |
| |
| // Attribute Type specific IDs |
| private static final String EQUALITY_ID = "EQUALITY"; |
| private static final String ORDERING_ID = "ORDERING"; |
| private static final String SUBSTR_ID = "SUBSTR"; |
| private static final String SYNTAX_ID = "SYNTAX"; |
| private static final String SINGLE_VAL_ID = "SINGLE-VALUE"; |
| private static final String COLLECTIVE_ID = "COLLECTIVE"; |
| private static final String NO_USER_MOD_ID = "NO-USER-MODIFICATION"; |
| private static final String USAGE_ID = "USAGE"; |
| |
| // The string value we give to boolean variables |
| private static final String SCHEMA_TRUE_VALUE = "true"; |
| |
| // To get around writing schemas that crash Netscape server |
| private boolean netscapeBug; |
| |
| LdapSchemaParser(boolean netscapeBug) { |
| this.netscapeBug = netscapeBug; |
| } |
| |
| final static void LDAP2JNDISchema(Attributes schemaAttrs, |
| LdapSchemaCtx schemaRoot) throws NamingException { |
| Attribute objectClassesAttr = null; |
| Attribute attributeDefAttr = null; |
| Attribute syntaxDefAttr = null; |
| Attribute matchRuleDefAttr = null; |
| |
| objectClassesAttr = schemaAttrs.get(OBJECTCLASSDESC_ATTR_ID); |
| if(objectClassesAttr != null) { |
| objectDescs2ClassDefs(objectClassesAttr,schemaRoot); |
| } |
| |
| attributeDefAttr = schemaAttrs.get(ATTRIBUTEDESC_ATTR_ID); |
| if(attributeDefAttr != null) { |
| attrDescs2AttrDefs(attributeDefAttr, schemaRoot); |
| } |
| |
| syntaxDefAttr = schemaAttrs.get(SYNTAXDESC_ATTR_ID); |
| if(syntaxDefAttr != null) { |
| syntaxDescs2SyntaxDefs(syntaxDefAttr, schemaRoot); |
| } |
| |
| matchRuleDefAttr = schemaAttrs.get(MATCHRULEDESC_ATTR_ID); |
| if(matchRuleDefAttr != null) { |
| matchRuleDescs2MatchRuleDefs(matchRuleDefAttr, schemaRoot); |
| } |
| } |
| |
| final private static DirContext objectDescs2ClassDefs(Attribute objDescsAttr, |
| LdapSchemaCtx schemaRoot) |
| throws NamingException { |
| |
| NamingEnumeration<?> objDescs; |
| Attributes objDef; |
| LdapSchemaCtx classDefTree; |
| |
| // create the class def subtree |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| attrs.put(CLASS_DEF_ATTRS[0], CLASS_DEF_ATTRS[1]); |
| classDefTree = schemaRoot.setup(LdapSchemaCtx.OBJECTCLASS_ROOT, |
| OBJECTCLASS_DEFINITION_NAME, attrs); |
| |
| objDescs = objDescsAttr.getAll(); |
| String currentName; |
| while(objDescs.hasMore()) { |
| String objDesc = (String)objDescs.next(); |
| try { |
| Object[] def = desc2Def(objDesc); |
| currentName = (String) def[0]; |
| objDef = (Attributes) def[1]; |
| classDefTree.setup(LdapSchemaCtx.OBJECTCLASS, |
| currentName, objDef); |
| } catch (NamingException ne) { |
| // error occurred while parsing, ignore current entry |
| } |
| } |
| |
| return classDefTree; |
| } |
| |
| final private static DirContext attrDescs2AttrDefs(Attribute attributeDescAttr, |
| LdapSchemaCtx schemaRoot) |
| throws NamingException { |
| |
| NamingEnumeration<?> attrDescs; |
| Attributes attrDef; |
| LdapSchemaCtx attrDefTree; |
| |
| // create the AttributeDef subtree |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| attrs.put(ATTR_DEF_ATTRS[0], ATTR_DEF_ATTRS[1]); |
| attrDefTree = schemaRoot.setup(LdapSchemaCtx.ATTRIBUTE_ROOT, |
| ATTRIBUTE_DEFINITION_NAME, attrs); |
| |
| attrDescs = attributeDescAttr.getAll(); |
| String currentName; |
| while(attrDescs.hasMore()) { |
| String attrDesc = (String)attrDescs.next(); |
| try { |
| Object[] def = desc2Def(attrDesc); |
| currentName = (String) def[0]; |
| attrDef = (Attributes) def[1]; |
| attrDefTree.setup(LdapSchemaCtx.ATTRIBUTE, |
| currentName, attrDef); |
| } catch (NamingException ne) { |
| // error occurred while parsing, ignore current entry |
| } |
| } |
| |
| return attrDefTree; |
| } |
| |
| final private static DirContext syntaxDescs2SyntaxDefs( |
| Attribute syntaxDescAttr, |
| LdapSchemaCtx schemaRoot) |
| throws NamingException { |
| |
| NamingEnumeration<?> syntaxDescs; |
| Attributes syntaxDef; |
| LdapSchemaCtx syntaxDefTree; |
| |
| // create the SyntaxDef subtree |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| attrs.put(SYNTAX_DEF_ATTRS[0], SYNTAX_DEF_ATTRS[1]); |
| syntaxDefTree = schemaRoot.setup(LdapSchemaCtx.SYNTAX_ROOT, |
| SYNTAX_DEFINITION_NAME, attrs); |
| |
| syntaxDescs = syntaxDescAttr.getAll(); |
| String currentName; |
| while(syntaxDescs.hasMore()) { |
| String syntaxDesc = (String)syntaxDescs.next(); |
| try { |
| Object[] def = desc2Def(syntaxDesc); |
| currentName = (String) def[0]; |
| syntaxDef = (Attributes) def[1]; |
| syntaxDefTree.setup(LdapSchemaCtx.SYNTAX, |
| currentName, syntaxDef); |
| } catch (NamingException ne) { |
| // error occurred while parsing, ignore current entry |
| } |
| } |
| |
| return syntaxDefTree; |
| } |
| |
| final private static DirContext matchRuleDescs2MatchRuleDefs( |
| Attribute matchRuleDescAttr, |
| LdapSchemaCtx schemaRoot) |
| throws NamingException { |
| |
| NamingEnumeration<?> matchRuleDescs; |
| Attributes matchRuleDef; |
| LdapSchemaCtx matchRuleDefTree; |
| |
| // create the MatchRuleDef subtree |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| attrs.put(MATCHRULE_DEF_ATTRS[0], MATCHRULE_DEF_ATTRS[1]); |
| matchRuleDefTree = schemaRoot.setup(LdapSchemaCtx.MATCHRULE_ROOT, |
| MATCHRULE_DEFINITION_NAME, attrs); |
| |
| matchRuleDescs = matchRuleDescAttr.getAll(); |
| String currentName; |
| while(matchRuleDescs.hasMore()) { |
| String matchRuleDesc = (String)matchRuleDescs.next(); |
| try { |
| Object[] def = desc2Def(matchRuleDesc); |
| currentName = (String) def[0]; |
| matchRuleDef = (Attributes) def[1]; |
| matchRuleDefTree.setup(LdapSchemaCtx.MATCHRULE, |
| currentName, matchRuleDef); |
| } catch (NamingException ne) { |
| // error occurred while parsing, ignore current entry |
| } |
| } |
| |
| return matchRuleDefTree; |
| } |
| |
| final private static Object[] desc2Def(String desc) |
| throws NamingException { |
| //System.err.println(desc); |
| |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| Attribute attr = null; |
| int[] pos = new int[]{1}; // tolerate missing leading space |
| boolean moreTags = true; |
| |
| // Always begins with <whsp numericoid whsp> |
| attr = readNumericOID(desc, pos); |
| String currentName = (String) attr.get(0); // name is OID by default |
| attrs.put(attr); |
| |
| skipWhitespace(desc, pos); |
| |
| while (moreTags) { |
| attr = readNextTag(desc, pos); |
| attrs.put(attr); |
| |
| if (attr.getID().equals(NAME_ID)) { |
| currentName = (String) attr.get(0); // use NAME attribute as name |
| } |
| |
| skipWhitespace(desc, pos); |
| |
| if( pos[0] >= desc.length() -1 ) { |
| moreTags = false; |
| } |
| } |
| |
| return new Object[] {currentName, attrs}; |
| } |
| |
| // returns the index of the first whitespace char of a linear whitspace |
| // sequince ending at the given position. |
| final private static int findTrailingWhitespace(String string, int pos) { |
| for(int i = pos; i > 0; i--) { |
| if(string.charAt(i) != WHSP) { |
| return i + 1; |
| } |
| } |
| return 0; |
| } |
| |
| final private static void skipWhitespace(String string, int[] pos) { |
| for(int i=pos[0]; i < string.length(); i++) { |
| if(string.charAt(i) != WHSP) { |
| pos[0] = i; |
| if (debug) { |
| System.err.println("skipWhitespace: skipping to "+i); |
| } |
| return; |
| } |
| } |
| } |
| |
| final private static Attribute readNumericOID(String string, int[] pos) |
| throws NamingException { |
| |
| if (debug) { |
| System.err.println("readNumericoid: pos="+pos[0]); |
| } |
| |
| int begin, end; |
| String value = null; |
| |
| skipWhitespace(string, pos); |
| |
| begin = pos[0]; |
| end = string.indexOf(WHSP, begin); |
| |
| if (end == -1 || end - begin < 1) { |
| throw new InvalidAttributeValueException("no numericoid found: " |
| + string); |
| } |
| |
| value = string.substring(begin, end); |
| |
| pos[0] += value.length(); |
| |
| return new BasicAttribute(NUMERICOID_ID, value); |
| } |
| |
| final private static Attribute readNextTag(String string, int[] pos) |
| throws NamingException { |
| |
| Attribute attr = null; |
| String tagName = null; |
| String[] values = null; |
| |
| skipWhitespace(string, pos); |
| |
| if (debug) { |
| System.err.println("readNextTag: pos="+pos[0]); |
| } |
| |
| // get the name and values of the attribute to return |
| int trailingSpace = string.indexOf( WHSP, pos[0] ); |
| |
| // tolerate a schema that omits the trailing space |
| if (trailingSpace < 0) { |
| tagName = string.substring( pos[0], string.length() - 1); |
| } else { |
| tagName = string.substring( pos[0], trailingSpace ); |
| } |
| |
| values = readTag(tagName, string, pos); |
| |
| // make sure at least one value was returned |
| if(values.length < 0) { |
| throw new InvalidAttributeValueException("no values for " + |
| "attribute \"" + |
| tagName + "\""); |
| } |
| |
| // create the attribute, using the first value |
| attr = new BasicAttribute(tagName, values[0]); |
| |
| // add other values if there are any |
| for(int i = 1; i < values.length; i++) { |
| attr.add(values[i]); |
| } |
| |
| return attr; |
| } |
| |
| final private static String[] readTag(String tag, String string, int[] pos) |
| throws NamingException { |
| |
| if (debug) { |
| System.err.println("ReadTag: " + tag + " pos="+pos[0]); |
| } |
| |
| // move parser past tag name |
| pos[0] += tag.length(); |
| skipWhitespace(string, pos); |
| |
| if (tag.equals(NAME_ID)) { |
| return readQDescrs(string, pos); // names[0] is NAME |
| } |
| |
| if(tag.equals(DESC_ID)) { |
| return readQDString(string, pos); |
| } |
| |
| if ( |
| tag.equals(EQUALITY_ID) || |
| tag.equals(ORDERING_ID) || |
| tag.equals(SUBSTR_ID) || |
| tag.equals(SYNTAX_ID)) { |
| return readWOID(string, pos); |
| } |
| |
| if (tag.equals(OBSOLETE_ID) || |
| tag.equals(ABSTRACT_ID) || |
| tag.equals(STRUCTURAL_ID) || |
| tag.equals(AUXILARY_ID) || |
| tag.equals(SINGLE_VAL_ID) || |
| tag.equals(COLLECTIVE_ID) || |
| tag.equals(NO_USER_MOD_ID)) { |
| return new String[] {SCHEMA_TRUE_VALUE}; |
| } |
| |
| if (tag.equals(SUP_ID) || // oid list for object class; WOID for attribute |
| tag.equals(MUST_ID) || |
| tag.equals(MAY_ID) || |
| tag.equals(USAGE_ID)) { |
| return readOIDs(string, pos); |
| } |
| |
| // otherwise it's a schema element with a quoted string value |
| return readQDStrings(string, pos); |
| } |
| |
| final private static String[] readQDString(String string, int[] pos) |
| throws NamingException { |
| |
| int begin, end; |
| |
| begin = string.indexOf(SINGLE_QUOTE, pos[0]) + 1; |
| end = string.indexOf(SINGLE_QUOTE, begin); |
| |
| if (debug) { |
| System.err.println("ReadQDString: pos=" + pos[0] + |
| " begin=" + begin + " end=" + end); |
| } |
| |
| if(begin == -1 || end == -1 || begin == end) { |
| throw new InvalidAttributeIdentifierException("malformed " + |
| "QDString: " + |
| string); |
| } |
| |
| // make sure the qdstring end symbol is there |
| if (string.charAt(begin - 1) != SINGLE_QUOTE) { |
| throw new InvalidAttributeIdentifierException("qdstring has " + |
| "no end mark: " + |
| string); |
| } |
| |
| pos[0] = end+1; |
| return new String[] {string.substring(begin, end)}; |
| } |
| |
| /** |
| * dstring = 1*utf8 |
| * qdstring = whsp "'" dstring "'" whsp |
| * qdstringlist = [ qdstring *( qdstring ) ] |
| * qdstrings = qdstring / ( whsp "(" qdstringlist ")" whsp ) |
| */ |
| private final static String[] readQDStrings(String string, int[] pos) |
| throws NamingException { |
| |
| return readQDescrs(string, pos); |
| } |
| |
| /** |
| * ; object descriptors used as schema element names |
| * qdescrs = qdescr / ( whsp "(" qdescrlist ")" whsp ) |
| * qdescrlist = [ qdescr *( qdescr ) ] |
| * qdescr = whsp "'" descr "'" whsp |
| * descr = keystring |
| */ |
| final private static String[] readQDescrs(String string, int[] pos) |
| throws NamingException { |
| |
| if (debug) { |
| System.err.println("readQDescrs: pos="+pos[0]); |
| } |
| |
| skipWhitespace(string, pos); |
| |
| switch( string.charAt(pos[0]) ) { |
| case OID_LIST_BEGIN: |
| return readQDescrList(string, pos); |
| case SINGLE_QUOTE: |
| return readQDString(string, pos); |
| default: |
| throw new InvalidAttributeValueException("unexpected oids " + |
| "string: " + string); |
| } |
| } |
| |
| /** |
| * qdescrlist = [ qdescr *( qdescr ) ] |
| * qdescr = whsp "'" descr "'" whsp |
| * descr = keystring |
| */ |
| final private static String[] readQDescrList(String string, int[] pos) |
| throws NamingException { |
| |
| int begin, end; |
| Vector<String> values = new Vector<>(5); |
| |
| if (debug) { |
| System.err.println("ReadQDescrList: pos="+pos[0]); |
| } |
| |
| pos[0]++; // skip '(' |
| skipWhitespace(string, pos); |
| begin = pos[0]; |
| end = string.indexOf(OID_LIST_END, begin); |
| |
| if(end == -1) { |
| throw new InvalidAttributeValueException ("oidlist has no end "+ |
| "mark: " + string); |
| } |
| |
| while(begin < end) { |
| String[] one = readQDString(string, pos); |
| |
| if (debug) { |
| System.err.println("ReadQDescrList: found '" + one[0] + |
| "' at begin=" + begin + " end =" + end); |
| } |
| |
| values.addElement(one[0]); |
| skipWhitespace(string, pos); |
| begin = pos[0]; |
| } |
| |
| pos[0] = end+1; // skip ')' |
| |
| String[] answer = new String[values.size()]; |
| for (int i = 0; i < answer.length; i++) { |
| answer[i] = values.elementAt(i); |
| } |
| return answer; |
| } |
| |
| final private static String[] readWOID(String string, int[] pos) |
| throws NamingException { |
| |
| if (debug) { |
| System.err.println("readWOIDs: pos="+pos[0]); |
| } |
| |
| skipWhitespace(string, pos); |
| |
| if (string.charAt(pos[0]) == SINGLE_QUOTE) { |
| // %%% workaround for Netscape schema bug |
| return readQDString(string, pos); |
| } |
| |
| int begin, end; |
| |
| begin = pos[0]; |
| end = string.indexOf(WHSP, begin); |
| |
| if (debug) { |
| System.err.println("ReadWOID: pos=" + pos[0] + |
| " begin=" + begin + " end=" + end); |
| } |
| |
| if(end == -1 || begin == end) { |
| throw new InvalidAttributeIdentifierException("malformed " + |
| "OID: " + |
| string); |
| } |
| pos[0] = end+1; |
| |
| return new String[] {string.substring(begin, end)}; |
| } |
| |
| /* |
| * oids = woid / ( "(" oidlist ")" ) |
| * oidlist = woid *( "$" woid ) |
| */ |
| final private static String[] readOIDs(String string, int[] pos) |
| throws NamingException { |
| |
| if (debug) { |
| System.err.println("readOIDs: pos="+pos[0]); |
| } |
| |
| skipWhitespace(string, pos); |
| |
| // Single OID |
| if (string.charAt(pos[0]) != OID_LIST_BEGIN) { |
| return readWOID(string, pos); |
| } |
| |
| // Multiple OIDs |
| |
| int begin, cur, end; |
| String oidName = null; |
| Vector<String> values = new Vector<>(5); |
| |
| if (debug) { |
| System.err.println("ReadOIDList: pos="+pos[0]); |
| } |
| |
| pos[0]++; |
| skipWhitespace(string, pos); |
| begin = pos[0]; |
| end = string.indexOf(OID_LIST_END, begin); |
| cur = string.indexOf(OID_SEPARATOR, begin); |
| |
| if(end == -1) { |
| throw new InvalidAttributeValueException ("oidlist has no end "+ |
| "mark: " + string); |
| } |
| |
| if(cur == -1 || end < cur) { |
| cur = end; |
| } |
| |
| while(cur < end && cur > 0) { |
| int wsBegin = findTrailingWhitespace(string, cur - 1); |
| oidName = string.substring(begin, wsBegin); |
| if (debug) { |
| System.err.println("ReadOIDList: found '" + oidName + |
| "' at begin=" + begin + " end =" + end); |
| } |
| values.addElement(oidName); |
| pos[0] = cur + 1; |
| skipWhitespace(string, pos); |
| begin = pos[0]; |
| cur = string.indexOf(OID_SEPARATOR, begin); |
| if(debug) {System.err.println("ReadOIDList: begin = " + begin);} |
| } |
| |
| if (debug) { |
| System.err.println("ReadOIDList: found '" + oidName + |
| "' at begin=" + begin + " end =" + end); |
| } |
| |
| int wsBegin = findTrailingWhitespace(string, end - 1); |
| oidName = string.substring(begin, wsBegin); |
| values.addElement(oidName); |
| |
| pos[0] = end+1; |
| |
| String[] answer = new String[values.size()]; |
| for (int i = 0; i < answer.length; i++) { |
| answer[i] = values.elementAt(i); |
| } |
| return answer; |
| } |
| |
| // ----------------- "unparser" methods |
| // Methods that are used for translating a node in the schema tree |
| // into RFC2252 format for storage back into the LDAP directory |
| /* |
| static Attributes JNDI2LDAPSchema(DirContext schemaRoot) |
| throws NamingException { |
| |
| Attribute objDescAttr = new BasicAttribute(OBJECTCLASSDESC_ATTR_ID); |
| Attribute attrDescAttr = new BasicAttribute(ATTRIBUTEDESC_ATTR_ID); |
| Attribute syntaxDescAttr = new BasicAttribute(SYNTAXDESC_ATTR_ID); |
| Attributes attrs = new BasicAttributes(LdapClient.caseIgnore); |
| DirContext classDefs, attributeDefs, syntaxDefs; |
| Attributes classDefsAttrs, attributeDefsAttrs, syntaxDefsAttrs; |
| NamingEnumeration defs; |
| Object obj; |
| int i = 0; |
| |
| try { |
| obj = schemaRoot.lookup(OBJECTCLASS_DEFINITION_NAME); |
| if(obj != null && obj instanceof DirContext) { |
| classDefs = (DirContext)obj; |
| defs = classDefs.listBindings(""); |
| while(defs.hasMoreElements()) { |
| i++; |
| DirContext classDef = (DirContext) |
| ((Binding)(defs.next())).getObject(); |
| classDefAttrs = classDef.getAttributes(""); |
| objDescAttr.add(classDef2ObjectDesc(classDefAttrs)); |
| } |
| if (debug) |
| System.err.println(i + " total object classes"); |
| attrs.put(objDescAttr); |
| } else { |
| throw new NamingException( |
| "Problem with Schema tree: the object named " + |
| OBJECTCLASS_DEFINITION_NAME + " is not a " + |
| "DirContext"); |
| } |
| } catch (NameNotFoundException e) {} // ignore |
| |
| i=0; |
| try { |
| obj = schemaRoot.lookup(ATTRIBUTE_DEFINITION_NAME); |
| if(obj instanceof DirContext) { |
| attributeDefs = (DirContext)obj; |
| defs = attributeDefs.listBindings(""); |
| while(defs.hasMoreElements()) { |
| i++; |
| DirContext attrDef = (DirContext) |
| ((Binding)defs.next()).getObject(); |
| attrDefAttrs = attrDef.getAttributes(""); |
| attrDescAttr.add(attrDef2AttrDesc(attrDefAttrs)); |
| } |
| if (debug) |
| System.err.println(i + " attribute definitions"); |
| attrs.put(attrDescAttr); |
| } else { |
| throw new NamingException( |
| "Problem with schema tree: the object named " + |
| ATTRIBUTE_DEFINITION_NAME + " is not a " + |
| "DirContext"); |
| } |
| } catch (NameNotFoundException e) {} // ignore |
| |
| i=0; |
| try { |
| obj = schemaRoot.lookup(SYNTAX_DEFINITION_NAME); |
| if(obj instanceof DirContext) { |
| syntaxDefs = (DirContext)obj; |
| defs =syntaxDefs.listBindings(""); |
| while(defs.hasMoreElements()) { |
| i++; |
| DirContext syntaxDef = (DirContext) |
| ((Binding)defs.next()).getObject(); |
| syntaxDefAttrs = syntaxDef.getAttributes(""); |
| syntaxDescAttr.add(syntaxDef2SyntaxDesc(syntaxDefAttrs)); |
| } |
| if (debug) |
| System.err.println(i + " total syntax definitions"); |
| attrs.put(syntaxDescAttr); |
| } else { |
| throw new NamingException( |
| "Problem with schema tree: the object named " + |
| SYNTAX_DEFINITION_NAME + " is not a " + |
| "DirContext"); |
| } |
| } catch (NameNotFoundException e) {} // ignore |
| |
| return attrs; |
| } |
| |
| */ |
| |
| /** |
| * Translate attributes that describe an object class into the |
| * string description as defined in RFC 2252. |
| */ |
| final private String classDef2ObjectDesc(Attributes attrs) |
| throws NamingException { |
| |
| StringBuffer objectDesc = new StringBuffer("( "); |
| |
| Attribute attr = null; |
| int count = 0; |
| |
| // extract attributes by ID to guarantee ordering |
| |
| attr = attrs.get(NUMERICOID_ID); |
| if (attr != null) { |
| objectDesc.append(writeNumericOID(attr)); |
| count++; |
| } else { |
| throw new ConfigurationException("Class definition doesn't" + |
| "have a numeric OID"); |
| } |
| |
| attr = attrs.get(NAME_ID); |
| if (attr != null) { |
| objectDesc.append(writeQDescrs(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(DESC_ID); |
| if (attr != null) { |
| objectDesc.append(writeQDString(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(OBSOLETE_ID); |
| if (attr != null) { |
| objectDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SUP_ID); |
| if (attr != null) { |
| objectDesc.append(writeOIDs(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(ABSTRACT_ID); |
| if (attr != null) { |
| objectDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(STRUCTURAL_ID); |
| if (attr != null) { |
| objectDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(AUXILARY_ID); |
| if (attr != null) { |
| objectDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(MUST_ID); |
| if (attr != null) { |
| objectDesc.append(writeOIDs(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(MAY_ID); |
| if (attr != null) { |
| objectDesc.append(writeOIDs(attr)); |
| count++; |
| } |
| |
| // process any remaining attributes |
| if (count < attrs.size()) { |
| String attrId = null; |
| |
| // use enumeration because attribute ID is not known |
| for (NamingEnumeration<? extends Attribute> ae = attrs.getAll(); |
| ae.hasMoreElements(); ) { |
| |
| attr = ae.next(); |
| attrId = attr.getID(); |
| |
| // skip those already processed |
| if (attrId.equals(NUMERICOID_ID) || |
| attrId.equals(NAME_ID) || |
| attrId.equals(SUP_ID) || |
| attrId.equals(MAY_ID) || |
| attrId.equals(MUST_ID) || |
| attrId.equals(STRUCTURAL_ID) || |
| attrId.equals(DESC_ID) || |
| attrId.equals(AUXILARY_ID) || |
| attrId.equals(ABSTRACT_ID) || |
| attrId.equals(OBSOLETE_ID)) { |
| continue; |
| |
| } else { |
| objectDesc.append(writeQDStrings(attr)); |
| } |
| } |
| } |
| |
| objectDesc.append(")"); |
| |
| return objectDesc.toString(); |
| } |
| |
| /** |
| * Translate attributes that describe an attribute definition into the |
| * string description as defined in RFC 2252. |
| */ |
| final private String attrDef2AttrDesc(Attributes attrs) |
| throws NamingException { |
| |
| StringBuffer attrDesc = new StringBuffer("( "); // opening parens |
| |
| Attribute attr = null; |
| int count = 0; |
| |
| // extract attributes by ID to guarantee ordering |
| |
| attr = attrs.get(NUMERICOID_ID); |
| if (attr != null) { |
| attrDesc.append(writeNumericOID(attr)); |
| count++; |
| } else { |
| throw new ConfigurationException("Attribute type doesn't" + |
| "have a numeric OID"); |
| } |
| |
| attr = attrs.get(NAME_ID); |
| if (attr != null) { |
| attrDesc.append(writeQDescrs(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(DESC_ID); |
| if (attr != null) { |
| attrDesc.append(writeQDString(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(OBSOLETE_ID); |
| if (attr != null) { |
| attrDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SUP_ID); |
| if (attr != null) { |
| attrDesc.append(writeWOID(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(EQUALITY_ID); |
| if (attr != null) { |
| attrDesc.append(writeWOID(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(ORDERING_ID); |
| if (attr != null) { |
| attrDesc.append(writeWOID(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SUBSTR_ID); |
| if (attr != null) { |
| attrDesc.append(writeWOID(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SYNTAX_ID); |
| if (attr != null) { |
| attrDesc.append(writeWOID(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SINGLE_VAL_ID); |
| if (attr != null) { |
| attrDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(COLLECTIVE_ID); |
| if (attr != null) { |
| attrDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(NO_USER_MOD_ID); |
| if (attr != null) { |
| attrDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(USAGE_ID); |
| if (attr != null) { |
| attrDesc.append(writeQDString(attr)); |
| count++; |
| } |
| |
| // process any remaining attributes |
| if (count < attrs.size()) { |
| String attrId = null; |
| |
| // use enumeration because attribute ID is not known |
| for (NamingEnumeration<? extends Attribute> ae = attrs.getAll(); |
| ae.hasMoreElements(); ) { |
| |
| attr = ae.next(); |
| attrId = attr.getID(); |
| |
| // skip those already processed |
| if (attrId.equals(NUMERICOID_ID) || |
| attrId.equals(NAME_ID) || |
| attrId.equals(SYNTAX_ID) || |
| attrId.equals(DESC_ID) || |
| attrId.equals(SINGLE_VAL_ID) || |
| attrId.equals(EQUALITY_ID) || |
| attrId.equals(ORDERING_ID) || |
| attrId.equals(SUBSTR_ID) || |
| attrId.equals(NO_USER_MOD_ID) || |
| attrId.equals(USAGE_ID) || |
| attrId.equals(SUP_ID) || |
| attrId.equals(COLLECTIVE_ID) || |
| attrId.equals(OBSOLETE_ID)) { |
| continue; |
| |
| } else { |
| attrDesc.append(writeQDStrings(attr)); |
| } |
| } |
| } |
| |
| attrDesc.append(")"); // add closing parens |
| |
| return attrDesc.toString(); |
| } |
| |
| /** |
| * Translate attributes that describe an attribute syntax definition into the |
| * string description as defined in RFC 2252. |
| */ |
| final private String syntaxDef2SyntaxDesc(Attributes attrs) |
| throws NamingException { |
| |
| StringBuffer syntaxDesc = new StringBuffer("( "); // opening parens |
| |
| Attribute attr = null; |
| int count = 0; |
| |
| // extract attributes by ID to guarantee ordering |
| |
| attr = attrs.get(NUMERICOID_ID); |
| if (attr != null) { |
| syntaxDesc.append(writeNumericOID(attr)); |
| count++; |
| } else { |
| throw new ConfigurationException("Attribute type doesn't" + |
| "have a numeric OID"); |
| } |
| |
| attr = attrs.get(DESC_ID); |
| if (attr != null) { |
| syntaxDesc.append(writeQDString(attr)); |
| count++; |
| } |
| |
| // process any remaining attributes |
| if (count < attrs.size()) { |
| String attrId = null; |
| |
| // use enumeration because attribute ID is not known |
| for (NamingEnumeration<? extends Attribute> ae = attrs.getAll(); |
| ae.hasMoreElements(); ) { |
| |
| attr = ae.next(); |
| attrId = attr.getID(); |
| |
| // skip those already processed |
| if (attrId.equals(NUMERICOID_ID) || |
| attrId.equals(DESC_ID)) { |
| continue; |
| |
| } else { |
| syntaxDesc.append(writeQDStrings(attr)); |
| } |
| } |
| } |
| |
| syntaxDesc.append(")"); |
| |
| return syntaxDesc.toString(); |
| } |
| |
| /** |
| * Translate attributes that describe an attribute matching rule |
| * definition into the string description as defined in RFC 2252. |
| */ |
| final private String matchRuleDef2MatchRuleDesc(Attributes attrs) |
| throws NamingException { |
| |
| StringBuffer matchRuleDesc = new StringBuffer("( "); // opening parens |
| |
| Attribute attr = null; |
| int count = 0; |
| |
| // extract attributes by ID to guarantee ordering |
| |
| attr = attrs.get(NUMERICOID_ID); |
| if (attr != null) { |
| matchRuleDesc.append(writeNumericOID(attr)); |
| count++; |
| } else { |
| throw new ConfigurationException("Attribute type doesn't" + |
| "have a numeric OID"); |
| } |
| |
| attr = attrs.get(NAME_ID); |
| if (attr != null) { |
| matchRuleDesc.append(writeQDescrs(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(DESC_ID); |
| if (attr != null) { |
| matchRuleDesc.append(writeQDString(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(OBSOLETE_ID); |
| if (attr != null) { |
| matchRuleDesc.append(writeBoolean(attr)); |
| count++; |
| } |
| |
| attr = attrs.get(SYNTAX_ID); |
| if (attr != null) { |
| matchRuleDesc.append(writeWOID(attr)); |
| count++; |
| } else { |
| throw new ConfigurationException("Attribute type doesn't" + |
| "have a syntax OID"); |
| } |
| |
| // process any remaining attributes |
| if (count < attrs.size()) { |
| String attrId = null; |
| |
| // use enumeration because attribute ID is not known |
| for (NamingEnumeration<? extends Attribute> ae = attrs.getAll(); |
| ae.hasMoreElements(); ) { |
| |
| attr = ae.next(); |
| attrId = attr.getID(); |
| |
| // skip those already processed |
| if (attrId.equals(NUMERICOID_ID) || |
| attrId.equals(NAME_ID) || |
| attrId.equals(SYNTAX_ID) || |
| attrId.equals(DESC_ID) || |
| attrId.equals(OBSOLETE_ID)) { |
| continue; |
| |
| } else { |
| matchRuleDesc.append(writeQDStrings(attr)); |
| } |
| } |
| } |
| |
| matchRuleDesc.append(")"); |
| |
| return matchRuleDesc.toString(); |
| } |
| |
| final private String writeNumericOID(Attribute nOIDAttr) |
| throws NamingException { |
| if(nOIDAttr.size() != 1) { |
| throw new InvalidAttributeValueException( |
| "A class definition must have exactly one numeric OID"); |
| } |
| return (String)(nOIDAttr.get()) + WHSP; |
| } |
| |
| final private String writeWOID(Attribute attr) throws NamingException { |
| if (netscapeBug) |
| return writeQDString(attr); |
| else |
| return attr.getID() + WHSP + attr.get() + WHSP; |
| } |
| |
| /* qdescr = whsp "'" descr "'" whsp */ |
| final private String writeQDString(Attribute qdStringAttr) |
| throws NamingException { |
| if(qdStringAttr.size() != 1) { |
| throw new InvalidAttributeValueException( |
| qdStringAttr.getID() + " must have exactly one value"); |
| } |
| |
| return qdStringAttr.getID() + WHSP + |
| SINGLE_QUOTE + qdStringAttr.get() + SINGLE_QUOTE + WHSP; |
| } |
| |
| /** |
| * dstring = 1*utf8 |
| * qdstring = whsp "'" dstring "'" whsp |
| * qdstringlist = [ qdstring *( qdstring ) ] |
| * qdstrings = qdstring / ( whsp "(" qdstringlist ")" whsp ) |
| */ |
| private final String writeQDStrings(Attribute attr) throws NamingException { |
| return writeQDescrs(attr); |
| } |
| |
| /** |
| * qdescrs = qdescr / ( whsp "(" qdescrlist ")" whsp ) |
| * qdescrlist = [ qdescr *( qdescr ) ] |
| * qdescr = whsp "'" descr "'" whsp |
| * descr = keystring |
| */ |
| private final String writeQDescrs(Attribute attr) throws NamingException { |
| switch(attr.size()) { |
| case 0: |
| throw new InvalidAttributeValueException( |
| attr.getID() + "has no values"); |
| case 1: |
| return writeQDString(attr); |
| } |
| |
| // write QDList |
| |
| StringBuffer qdList = new StringBuffer(attr.getID()); |
| qdList.append(WHSP); |
| qdList.append(OID_LIST_BEGIN); |
| |
| NamingEnumeration<?> values = attr.getAll(); |
| |
| while(values.hasMore()) { |
| qdList.append(WHSP); |
| qdList.append(SINGLE_QUOTE); |
| qdList.append((String)values.next()); |
| qdList.append(SINGLE_QUOTE); |
| qdList.append(WHSP); |
| } |
| |
| qdList.append(OID_LIST_END); |
| qdList.append(WHSP); |
| |
| return qdList.toString(); |
| } |
| |
| final private String writeOIDs(Attribute oidsAttr) |
| throws NamingException { |
| |
| switch(oidsAttr.size()) { |
| case 0: |
| throw new InvalidAttributeValueException( |
| oidsAttr.getID() + "has no values"); |
| |
| case 1: |
| if (netscapeBug) { |
| break; // %%% write out as list to avoid crashing server |
| } |
| return writeWOID(oidsAttr); |
| } |
| |
| // write OID List |
| |
| StringBuffer oidList = new StringBuffer(oidsAttr.getID()); |
| oidList.append(WHSP); |
| oidList.append(OID_LIST_BEGIN); |
| |
| NamingEnumeration<?> values = oidsAttr.getAll(); |
| oidList.append(WHSP); |
| oidList.append(values.next()); |
| |
| while(values.hasMore()) { |
| oidList.append(WHSP); |
| oidList.append(OID_SEPARATOR); |
| oidList.append(WHSP); |
| oidList.append((String)values.next()); |
| } |
| |
| oidList.append(WHSP); |
| oidList.append(OID_LIST_END); |
| oidList.append(WHSP); |
| |
| return oidList.toString(); |
| } |
| |
| private final String writeBoolean(Attribute booleanAttr) |
| throws NamingException { |
| return booleanAttr.getID() + WHSP; |
| } |
| |
| /** |
| * Returns an attribute for updating the Object Class Definition schema |
| * attribute |
| */ |
| final Attribute stringifyObjDesc(Attributes classDefAttrs) |
| throws NamingException { |
| Attribute objDescAttr = new BasicAttribute(OBJECTCLASSDESC_ATTR_ID); |
| objDescAttr.add(classDef2ObjectDesc(classDefAttrs)); |
| return objDescAttr; |
| } |
| |
| /** |
| * Returns an attribute for updating the Attribute Definition schema attribute |
| */ |
| final Attribute stringifyAttrDesc(Attributes attrDefAttrs) |
| throws NamingException { |
| Attribute attrDescAttr = new BasicAttribute(ATTRIBUTEDESC_ATTR_ID); |
| attrDescAttr.add(attrDef2AttrDesc(attrDefAttrs)); |
| return attrDescAttr; |
| } |
| |
| /** |
| * Returns an attribute for updating the Syntax schema attribute |
| */ |
| final Attribute stringifySyntaxDesc(Attributes syntaxDefAttrs) |
| throws NamingException { |
| Attribute syntaxDescAttr = new BasicAttribute(SYNTAXDESC_ATTR_ID); |
| syntaxDescAttr.add(syntaxDef2SyntaxDesc(syntaxDefAttrs)); |
| return syntaxDescAttr; |
| } |
| |
| /** |
| * Returns an attribute for updating the Matching Rule schema attribute |
| */ |
| final Attribute stringifyMatchRuleDesc(Attributes matchRuleDefAttrs) |
| throws NamingException { |
| Attribute matchRuleDescAttr = new BasicAttribute(MATCHRULEDESC_ATTR_ID); |
| matchRuleDescAttr.add(matchRuleDef2MatchRuleDesc(matchRuleDefAttrs)); |
| return matchRuleDescAttr; |
| } |
| } |
