Back to index...

	/*
	* 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.Hashtable;
	import com.sun.jndi.toolkit.dir.HierMemDirCtx;

	/**
	* This is the class used to implement LDAP's GetSchema call.
	*
	* It subclasses HierMemDirContext for most of the functionality. It
	* overrides functions that cause the schema definitions to change.
	* In such a case, it write the schema to the LdapServer and (assuming
	* there are no errors), calls it's superclass's equivalent function.
	* Thus, the schema tree and the LDAP server's schema attributes are
	* always in sync.
	*/

	final class LdapSchemaCtx extends HierMemDirCtx {

	static private final boolean debug = false;

	private static final int LEAF = 0; // schema object (e.g. attribute type defn)
	private static final int SCHEMA_ROOT = 1; // schema tree root
	static final int OBJECTCLASS_ROOT = 2; // root of object class subtree
	static final int ATTRIBUTE_ROOT = 3; // root of attribute type subtree
	static final int SYNTAX_ROOT = 4; // root of syntax subtree
	static final int MATCHRULE_ROOT = 5; // root of matching rule subtree
	static final int OBJECTCLASS = 6; // an object class definition
	static final int ATTRIBUTE = 7; // an attribute type definition
	static final int SYNTAX = 8; // a syntax definition
	static final int MATCHRULE = 9; // a matching rule definition

	private SchemaInfo info= null;
	private boolean setupMode = true;

	private int objectType;

	static DirContext createSchemaTree(Hashtable<String,Object> env,
	String subschemasubentry, LdapCtx schemaEntry,
	Attributes schemaAttrs, boolean netscapeBug)
	throws NamingException {
	try {
	LdapSchemaParser parser = new LdapSchemaParser(netscapeBug);

	SchemaInfo allinfo = new SchemaInfo(subschemasubentry,
	schemaEntry, parser);

	LdapSchemaCtx root = new LdapSchemaCtx(SCHEMA_ROOT, env, allinfo);
	LdapSchemaParser.LDAP2JNDISchema(schemaAttrs, root);
	return root;
	} catch (NamingException e) {
	schemaEntry.close(); // cleanup
	throw e;
	}
	}

	// Called by createNewCtx
	private LdapSchemaCtx(int objectType, Hashtable<String,Object> environment,
	SchemaInfo info) {
	super(environment, LdapClient.caseIgnore);

	this.objectType = objectType;
	this.info = info;
	}

	// override HierMemDirCtx.close to prevent premature GC of shared data
	public void close() throws NamingException {
	info.close();
	}

	// override to ignore obj and use attrs
	// treat same as createSubcontext
	final public void bind(Name name, Object obj, Attributes attrs)
	throws NamingException {
	if (!setupMode) {
	if (obj != null) {
	throw new IllegalArgumentException("obj must be null");
	}

	// Update server
	addServerSchema(attrs);
	}

	// Update in-memory copy
	LdapSchemaCtx newEntry =
	(LdapSchemaCtx)super.doCreateSubcontext(name, attrs);
	}

	final protected void doBind(Name name, Object obj, Attributes attrs,
	boolean useFactory) throws NamingException {
	if (!setupMode) {
	throw new SchemaViolationException(
	"Cannot bind arbitrary object; use createSubcontext()");
	} else {
	super.doBind(name, obj, attrs, false); // always ignore factories
	}
	}

	// override to use bind() instead
	final public void rebind(Name name, Object obj, Attributes attrs)
	throws NamingException {
	try {
	doLookup(name, false);
	throw new SchemaViolationException(
	"Cannot replace existing schema object");
	} catch (NameNotFoundException e) {
	bind(name, obj, attrs);
	}
	}

	final protected void doRebind(Name name, Object obj, Attributes attrs,
	boolean useFactory) throws NamingException {
	if (!setupMode) {
	throw new SchemaViolationException(
	"Cannot bind arbitrary object; use createSubcontext()");
	} else {
	super.doRebind(name, obj, attrs, false); // always ignore factories
	}
	}

	final protected void doUnbind(Name name) throws NamingException {
	if (!setupMode) {
	// Update server
	try {
	// Lookup entry from memory
	LdapSchemaCtx target = (LdapSchemaCtx)doLookup(name, false);

	deleteServerSchema(target.attrs);
	} catch (NameNotFoundException e) {
	return;
	}
	}
	// Update in-memory copy
	super.doUnbind(name);
	}

	final protected void doRename(Name oldname, Name newname)
	throws NamingException {
	if (!setupMode) {
	throw new SchemaViolationException("Cannot rename a schema object");
	} else {
	super.doRename(oldname, newname);
	}
	}

	final protected void doDestroySubcontext(Name name) throws NamingException {
	if (!setupMode) {
	// Update server
	try {
	// Lookup entry from memory
	LdapSchemaCtx target = (LdapSchemaCtx)doLookup(name, false);

	deleteServerSchema(target.attrs);
	} catch (NameNotFoundException e) {
	return;
	}
	}

	// Update in-memory copy
	super.doDestroySubcontext(name);
	}

	// Called to create oc, attr, syntax or matching rule roots and leaf entries
	final LdapSchemaCtx setup(int objectType, String name, Attributes attrs)
	throws NamingException{
	try {
	setupMode = true;
	LdapSchemaCtx answer =
	(LdapSchemaCtx) super.doCreateSubcontext(
	new CompositeName(name), attrs);

	answer.objectType = objectType;
	answer.setupMode = false;
	return answer;
	} finally {
	setupMode = false;
	}
	}

	final protected DirContext doCreateSubcontext(Name name, Attributes attrs)
	throws NamingException {

	if (attrs == null \|\| attrs.size() == 0) {
	throw new SchemaViolationException(
	"Must supply attributes describing schema");
	}

	if (!setupMode) {
	// Update server
	addServerSchema(attrs);
	}

	// Update in-memory copy
	LdapSchemaCtx newEntry =
	(LdapSchemaCtx) super.doCreateSubcontext(name, attrs);
	return newEntry;
	}

	final private static Attributes deepClone(Attributes orig)
	throws NamingException {
	BasicAttributes copy = new BasicAttributes(true);
	NamingEnumeration<? extends Attribute> attrs = orig.getAll();
	while (attrs.hasMore()) {
	copy.put((Attribute)attrs.next().clone());
	}
	return copy;
	}

	final protected void doModifyAttributes(ModificationItem[] mods)
	throws NamingException {
	if (setupMode) {
	super.doModifyAttributes(mods);
	} else {
	Attributes copy = deepClone(attrs);

	// Apply modifications to copy
	applyMods(mods, copy);

	// Update server copy
	modifyServerSchema(attrs, copy);

	// Update in-memory copy
	attrs = copy;
	}
	}

	// we override this so the superclass creates the right kind of contexts
	// Default is to create LEAF objects; caller will change after creation
	// if necessary
	final protected HierMemDirCtx createNewCtx() {
	LdapSchemaCtx ctx = new LdapSchemaCtx(LEAF, myEnv, info);
	return ctx;
	}


	final private void addServerSchema(Attributes attrs)
	throws NamingException {
	Attribute schemaAttr;

	switch (objectType) {
	case OBJECTCLASS_ROOT:
	schemaAttr = info.parser.stringifyObjDesc(attrs);
	break;

	case ATTRIBUTE_ROOT:
	schemaAttr = info.parser.stringifyAttrDesc(attrs);
	break;

	case SYNTAX_ROOT:
	schemaAttr = info.parser.stringifySyntaxDesc(attrs);
	break;

	case MATCHRULE_ROOT:
	schemaAttr = info.parser.stringifyMatchRuleDesc(attrs);
	break;

	case SCHEMA_ROOT:
	throw new SchemaViolationException(
	"Cannot create new entry under schema root");

	default:
	throw new SchemaViolationException(
	"Cannot create child of schema object");
	}

	Attributes holder = new BasicAttributes(true);
	holder.put(schemaAttr);
	//System.err.println((String)schemaAttr.get());

	info.modifyAttributes(myEnv, DirContext.ADD_ATTRIBUTE, holder);

	}

	/**
	* When we delete an entry, we use the original to make sure that
	* any formatting inconsistencies are eliminated.
	* This is because we're just deleting a value from an attribute
	* on the server and there might not be any checks for extra spaces
	* or parens.
	*/
	final private void deleteServerSchema(Attributes origAttrs)
	throws NamingException {

	Attribute origAttrVal;

	switch (objectType) {
	case OBJECTCLASS_ROOT:
	origAttrVal = info.parser.stringifyObjDesc(origAttrs);
	break;

	case ATTRIBUTE_ROOT:
	origAttrVal = info.parser.stringifyAttrDesc(origAttrs);
	break;

	case SYNTAX_ROOT:
	origAttrVal = info.parser.stringifySyntaxDesc(origAttrs);
	break;

	case MATCHRULE_ROOT:
	origAttrVal = info.parser.stringifyMatchRuleDesc(origAttrs);
	break;

	case SCHEMA_ROOT:
	throw new SchemaViolationException(
	"Cannot delete schema root");

	default:
	throw new SchemaViolationException(
	"Cannot delete child of schema object");
	}

	ModificationItem[] mods = new ModificationItem[1];
	mods[0] = new ModificationItem(DirContext.REMOVE_ATTRIBUTE, origAttrVal);

	info.modifyAttributes(myEnv, mods);
	}

	/**
	* When we modify an entry, we use the original attribute value
	* in the schema to make sure that any formatting inconsistencies
	* are eliminated. A modification is done by deleting the original
	* value and adding a new value with the modification.
	*/
	final private void modifyServerSchema(Attributes origAttrs,
	Attributes newAttrs) throws NamingException {

	Attribute newAttrVal;
	Attribute origAttrVal;

	switch (objectType) {
	case OBJECTCLASS:
	origAttrVal = info.parser.stringifyObjDesc(origAttrs);
	newAttrVal = info.parser.stringifyObjDesc(newAttrs);
	break;

	case ATTRIBUTE:
	origAttrVal = info.parser.stringifyAttrDesc(origAttrs);
	newAttrVal = info.parser.stringifyAttrDesc(newAttrs);
	break;

	case SYNTAX:
	origAttrVal = info.parser.stringifySyntaxDesc(origAttrs);
	newAttrVal = info.parser.stringifySyntaxDesc(newAttrs);
	break;

	case MATCHRULE:
	origAttrVal = info.parser.stringifyMatchRuleDesc(origAttrs);
	newAttrVal = info.parser.stringifyMatchRuleDesc(newAttrs);
	break;

	default:
	throw new SchemaViolationException(
	"Cannot modify schema root");
	}

	ModificationItem[] mods = new ModificationItem[2];
	mods[0] = new ModificationItem(DirContext.REMOVE_ATTRIBUTE, origAttrVal);
	mods[1] = new ModificationItem(DirContext.ADD_ATTRIBUTE, newAttrVal);

	info.modifyAttributes(myEnv, mods);
	}

	final static private class SchemaInfo {
	private LdapCtx schemaEntry;
	private String schemaEntryName;
	LdapSchemaParser parser;
	private String host;
	private int port;
	private boolean hasLdapsScheme;

	SchemaInfo(String schemaEntryName, LdapCtx schemaEntry,
	LdapSchemaParser parser) {
	this.schemaEntryName = schemaEntryName;
	this.schemaEntry = schemaEntry;
	this.parser = parser;
	this.port = schemaEntry.port_number;
	this.host = schemaEntry.hostname;
	this.hasLdapsScheme = schemaEntry.hasLdapsScheme;
	}

	synchronized void close() throws NamingException {
	if (schemaEntry != null) {
	schemaEntry.close();
	schemaEntry = null;
	}
	}

	private LdapCtx reopenEntry(Hashtable<?,?> env) throws NamingException {
	// Use subschemasubentry name as DN
	return new LdapCtx(schemaEntryName, host, port,
	env, hasLdapsScheme);
	}

	synchronized void modifyAttributes(Hashtable<?,?> env,
	ModificationItem[] mods)
	throws NamingException {
	if (schemaEntry == null) {
	schemaEntry = reopenEntry(env);
	}
	schemaEntry.modifyAttributes("", mods);
	}

	synchronized void modifyAttributes(Hashtable<?,?> env, int mod,
	Attributes attrs) throws NamingException {
	if (schemaEntry == null) {
	schemaEntry = reopenEntry(env);
	}
	schemaEntry.modifyAttributes("", mod, attrs);
	}
	}
	}

Back to index...