/*
* Copyright (c) 1999, 2002, 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 javax.naming.spi.*;
import java.util.*;
/**
* A sample service provider that implements a hierarchical directory in memory.
* Every operation begins by doing a lookup on the name passed to it and then
* calls a corresponding "do<OperationName>" on the result of the lookup. The
* "do<OperationName>" does the work without any further resolution (it assumes
* that it is the target context).
*/
public class HierMemDirCtx implements DirContext {
static private final boolean debug = false;
private static final NameParser defaultParser = new HierarchicalNameParser();
protected Hashtable myEnv;
protected Hashtable bindings;
protected Attributes attrs;
protected boolean ignoreCase = false;
protected NamingException readOnlyEx = null;
protected NameParser myParser = defaultParser;
private boolean alwaysUseFactory;
public void close() throws NamingException {
myEnv = null;
bindings = null;
attrs = null;
}
public String getNameInNamespace() throws NamingException {
throw new OperationNotSupportedException(
"Cannot determine full name");
}
public HierMemDirCtx() {
this(null, false, false);
}
public HierMemDirCtx(boolean ignoreCase) {
this(null, ignoreCase, false);
}
public HierMemDirCtx(Hashtable environment, boolean ignoreCase) {
this(environment, ignoreCase, false);
}
protected HierMemDirCtx(Hashtable environment, boolean ignoreCase,
boolean useFac) {
myEnv = environment;
this.ignoreCase = ignoreCase;
init();
this.alwaysUseFactory = useFac;
}
private void init() {
attrs = new BasicAttributes(ignoreCase);
bindings = new Hashtable(11, 0.75f);
}
public Object lookup(String name) throws NamingException {
return lookup(myParser.parse(name));
}
public Object lookup(Name name) throws NamingException {
return doLookup(name, alwaysUseFactory);
}
public Object doLookup(Name name, boolean useFactory)
throws NamingException {
Object target = null;
name = canonizeName(name);
switch(name.size()) {
case 0:
// name is empty, caller wants this object
target = this;
break;
case 1:
// name is atomic, caller wants one of this object's bindings
target = bindings.get(name);
break;
default:
// name is compound, delegate to child context
HierMemDirCtx ctx = (HierMemDirCtx)bindings.get(name.getPrefix(1));
if(ctx == null) {
target = null;
} else {
target = ctx.doLookup(name.getSuffix(1), false);
}
break;
}
if(target == null) {
throw new NameNotFoundException(name.toString());
}
if (useFactory) {
try {
return DirectoryManager.getObjectInstance(target,
name, this, myEnv,
(target instanceof HierMemDirCtx) ?
((HierMemDirCtx)target).attrs : null);
} catch (NamingException e) {
throw e;
} catch (Exception e) {
NamingException e2 = new NamingException(
"Problem calling getObjectInstance");
e2.setRootCause(e);
throw e2;
}
} else {
return target;
}
}
public void bind(String name, Object obj) throws NamingException {
bind(myParser.parse(name), obj);
}
public void bind(Name name, Object obj) throws NamingException {
doBind(name, obj, null, alwaysUseFactory);
}
public void bind(String name, Object obj, Attributes attrs)
throws NamingException {
bind(myParser.parse(name), obj, attrs);
}
public void bind(Name name, Object obj, Attributes attrs)
throws NamingException {
doBind(name, obj, attrs, alwaysUseFactory);
}
protected void doBind(Name name, Object obj, Attributes attrs,
boolean useFactory) throws NamingException {
if (name.isEmpty()) {
throw new InvalidNameException("Cannot bind empty name");
}
if (useFactory) {
DirStateFactory.Result res = DirectoryManager.getStateToBind(
obj, name, this, myEnv, attrs);
obj = res.getObject();
attrs = res.getAttributes();
}
HierMemDirCtx ctx= (HierMemDirCtx) doLookup(getInternalName(name), false);
ctx.doBindAux(getLeafName(name), obj);
if (attrs != null && attrs.size() > 0) {
modifyAttributes(name, ADD_ATTRIBUTE, attrs);
}
}
protected void doBindAux(Name name, Object obj) throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
if (bindings.get(name) != null) {
throw new NameAlreadyBoundException(name.toString());
}
if(obj instanceof HierMemDirCtx) {
bindings.put(name, obj);
} else {
throw new SchemaViolationException(
"This context only supports binding objects of it's own kind");
}
}
public void rebind(String name, Object obj) throws NamingException {
rebind(myParser.parse(name), obj);
}
public void rebind(Name name, Object obj) throws NamingException {
doRebind(name, obj, null, alwaysUseFactory);
}
public void rebind(String name, Object obj, Attributes attrs)
throws NamingException {
rebind(myParser.parse(name), obj, attrs);
}
public void rebind(Name name, Object obj, Attributes attrs)
throws NamingException {
doRebind(name, obj, attrs, alwaysUseFactory);
}
protected void doRebind(Name name, Object obj, Attributes attrs,
boolean useFactory) throws NamingException {
if (name.isEmpty()) {
throw new InvalidNameException("Cannot rebind empty name");
}
if (useFactory) {
DirStateFactory.Result res = DirectoryManager.getStateToBind(
obj, name, this, myEnv, attrs);
obj = res.getObject();
attrs = res.getAttributes();
}
HierMemDirCtx ctx= (HierMemDirCtx) doLookup(getInternalName(name), false);
ctx.doRebindAux(getLeafName(name), obj);
//
// attrs == null -> use attrs from obj
// attrs != null -> use attrs
//
// %%% Strictly speaking, when attrs is non-null, we should
// take the explicit step of removing obj's attrs.
// We don't do that currently.
if (attrs != null && attrs.size() > 0) {
modifyAttributes(name, ADD_ATTRIBUTE, attrs);
}
}
protected void doRebindAux(Name name, Object obj) throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
if(obj instanceof HierMemDirCtx) {
bindings.put(name, obj);
} else {
throw new SchemaViolationException(
"This context only supports binding objects of it's own kind");
}
}
public void unbind(String name) throws NamingException {
unbind(myParser.parse(name));
}
public void unbind(Name name) throws NamingException {
if (name.isEmpty()) {
throw new InvalidNameException("Cannot unbind empty name");
} else {
HierMemDirCtx ctx=
(HierMemDirCtx) doLookup(getInternalName(name), false);
ctx.doUnbind(getLeafName(name));
}
}
protected void doUnbind(Name name) throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
bindings.remove(name); // attrs will also be removed along with ctx
}
public void rename(String oldname, String newname)
throws NamingException {
rename(myParser.parse(oldname), myParser.parse(newname));
}
public void rename(Name oldname, Name newname)
throws NamingException {
if(newname.isEmpty() || oldname.isEmpty()) {
throw new InvalidNameException("Cannot rename empty name");
}
if (!getInternalName(newname).equals(getInternalName(oldname))) {
throw new InvalidNameException("Cannot rename across contexts");
}
HierMemDirCtx ctx =
(HierMemDirCtx) doLookup(getInternalName(newname), false);
ctx.doRename(getLeafName(oldname), getLeafName(newname));
}
protected void doRename(Name oldname, Name newname) throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
oldname = canonizeName(oldname);
newname = canonizeName(newname);
// Check if new name exists
if (bindings.get(newname) != null) {
throw new NameAlreadyBoundException(newname.toString());
}
// Check if old name is bound
Object oldBinding = bindings.remove(oldname);
if (oldBinding == null) {
throw new NameNotFoundException(oldname.toString());
}
bindings.put(newname, oldBinding);
}
public NamingEnumeration list(String name) throws NamingException {
return list(myParser.parse(name));
}
public NamingEnumeration list(Name name) throws NamingException {
HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
return ctx.doList();
}
protected NamingEnumeration doList () throws NamingException {
return new FlatNames(bindings.keys());
}
public NamingEnumeration listBindings(String name) throws NamingException {
return listBindings(myParser.parse(name));
}
public NamingEnumeration listBindings(Name name) throws NamingException {
HierMemDirCtx ctx = (HierMemDirCtx)doLookup(name, false);
return ctx.doListBindings(alwaysUseFactory);
}
protected NamingEnumeration doListBindings(boolean useFactory)
throws NamingException {
return new FlatBindings(bindings, myEnv, useFactory);
}
public void destroySubcontext(String name) throws NamingException {
destroySubcontext(myParser.parse(name));
}
public void destroySubcontext(Name name) throws NamingException {
HierMemDirCtx ctx =
(HierMemDirCtx) doLookup(getInternalName(name), false);
ctx.doDestroySubcontext(getLeafName(name));
}
protected void doDestroySubcontext(Name name) throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
name = canonizeName(name);
bindings.remove(name);
}
public Context createSubcontext(String name) throws NamingException {
return createSubcontext(myParser.parse(name));
}
public Context createSubcontext(Name name) throws NamingException {
return createSubcontext(name, null);
}
public DirContext createSubcontext(String name, Attributes attrs)
throws NamingException {
return createSubcontext(myParser.parse(name), attrs);
}
public DirContext createSubcontext(Name name, Attributes attrs)
throws NamingException {
HierMemDirCtx ctx =
(HierMemDirCtx) doLookup(getInternalName(name), false);
return ctx.doCreateSubcontext(getLeafName(name), attrs);
}
protected DirContext doCreateSubcontext(Name name, Attributes attrs)
throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
name = canonizeName(name);
if (bindings.get(name) != null) {
throw new NameAlreadyBoundException(name.toString());
}
HierMemDirCtx newCtx = createNewCtx();
bindings.put(name, newCtx);
if(attrs != null) {
newCtx.modifyAttributes("", ADD_ATTRIBUTE, attrs);
}
return newCtx;
}
public Object lookupLink(String name) throws NamingException {
// This context does not treat links specially
return lookupLink(myParser.parse(name));
}
public Object lookupLink(Name name) throws NamingException {
// Flat namespace; no federation; just call string version
return lookup(name);
}
public NameParser getNameParser(String name) throws NamingException {
return myParser;
}
public NameParser getNameParser(Name name) throws NamingException {
return myParser;
}
public String composeName(String name, String prefix)
throws NamingException {
Name result = composeName(new CompositeName(name),
new CompositeName(prefix));
return result.toString();
}
public Name composeName(Name name, Name prefix)
throws NamingException {
name = canonizeName(name);
prefix = canonizeName(prefix);
Name result = (Name)(prefix.clone());
result.addAll(name);
return result;
}
public Object addToEnvironment(String propName, Object propVal)
throws NamingException {
myEnv = (myEnv == null) ?
new Hashtable(11, 0.75f) : (Hashtable)myEnv.clone();
return myEnv.put(propName, propVal);
}
public Object removeFromEnvironment(String propName)
throws NamingException {
if (myEnv == null)
return null;
myEnv = (Hashtable)myEnv.clone();
return myEnv.remove(propName);
}
public Hashtable getEnvironment() throws NamingException {
if (myEnv == null) {
return new Hashtable(5, 0.75f);
} else {
return (Hashtable)myEnv.clone();
}
}
public Attributes getAttributes(String name)
throws NamingException {
return getAttributes(myParser.parse(name));
}
public Attributes getAttributes(Name name)
throws NamingException {
HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
return ctx.doGetAttributes();
}
protected Attributes doGetAttributes() throws NamingException {
return (Attributes)attrs.clone();
}
public Attributes getAttributes(String name, String[] attrIds)
throws NamingException {
return getAttributes(myParser.parse(name), attrIds);
}
public Attributes getAttributes(Name name, String[] attrIds)
throws NamingException {
HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
return ctx.doGetAttributes(attrIds);
}
protected Attributes doGetAttributes(String[] attrIds)
throws NamingException {
if (attrIds == null) {
return doGetAttributes();
}
Attributes attrs = new BasicAttributes(ignoreCase);
Attribute attr = null;
for(int i=0; i<attrIds.length; i++) {
attr = this.attrs.get(attrIds[i]);
if (attr != null) {
attrs.put(attr);
}
}
return attrs;
}
public void modifyAttributes(String name, int mod_op, Attributes attrs)
throws NamingException {
modifyAttributes(myParser.parse(name), mod_op, attrs);
}
public void modifyAttributes(Name name, int mod_op, Attributes attrs)
throws NamingException {
if (attrs == null || attrs.size() == 0) {
throw new IllegalArgumentException(
"Cannot modify without an attribute");
}
// turn it into a modification Enumeration and pass it on
NamingEnumeration attrEnum = attrs.getAll();
ModificationItem[] mods = new ModificationItem[attrs.size()];
for (int i = 0; i < mods.length && attrEnum.hasMoreElements(); i++) {
mods[i] = new ModificationItem(mod_op, (Attribute)attrEnum.next());
}
modifyAttributes(name, mods);
}
public void modifyAttributes(String name, ModificationItem[] mods)
throws NamingException {
modifyAttributes(myParser.parse(name), mods);
}
public void modifyAttributes(Name name, ModificationItem[] mods)
throws NamingException {
HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
ctx.doModifyAttributes(mods);
}
protected void doModifyAttributes(ModificationItem[] mods)
throws NamingException {
if (readOnlyEx != null) {
throw (NamingException) readOnlyEx.fillInStackTrace();
}
applyMods(mods, attrs);
}
protected static Attributes applyMods(ModificationItem[] mods,
Attributes orig) throws NamingException {
ModificationItem mod;
Attribute existingAttr, modAttr;
NamingEnumeration modVals;
for (int i = 0; i < mods.length; i++) {
mod = mods[i];
modAttr = mod.getAttribute();
switch(mod.getModificationOp()) {
case ADD_ATTRIBUTE:
if (debug) {
System.out.println("HierMemDSCtx: adding " +
mod.getAttribute().toString());
}
existingAttr = orig.get(modAttr.getID());
if (existingAttr == null) {
orig.put((Attribute)modAttr.clone());
} else {
// Add new attribute values to existing attribute
modVals = modAttr.getAll();
while (modVals.hasMore()) {
existingAttr.add(modVals.next());
}
}
break;
case REPLACE_ATTRIBUTE:
if (modAttr.size() == 0) {
orig.remove(modAttr.getID());
} else {
orig.put((Attribute)modAttr.clone());
}
break;
case REMOVE_ATTRIBUTE:
existingAttr = orig.get(modAttr.getID());
if (existingAttr != null) {
if (modAttr.size() == 0) {
orig.remove(modAttr.getID());
} else {
// Remove attribute values from existing attribute
modVals = modAttr.getAll();
while (modVals.hasMore()) {
existingAttr.remove(modVals.next());
}
if (existingAttr.size() == 0) {
orig.remove(modAttr.getID());
}
}
}
break;
default:
throw new AttributeModificationException("Unknown mod_op");
}
}
return orig;
}
public NamingEnumeration search(String name,
Attributes matchingAttributes)
throws NamingException {
return search(name, matchingAttributes, null);
}
public NamingEnumeration search(Name name,
Attributes matchingAttributes)
throws NamingException {
return search(name, matchingAttributes, null);
}
public NamingEnumeration search(String name,
Attributes matchingAttributes,
String[] attributesToReturn)
throws NamingException {
return search(myParser.parse(name), matchingAttributes,
attributesToReturn);
}
public NamingEnumeration search(Name name,
Attributes matchingAttributes,
String[] attributesToReturn)
throws NamingException {
HierMemDirCtx target = (HierMemDirCtx) doLookup(name, false);
SearchControls cons = new SearchControls();
cons.setReturningAttributes(attributesToReturn);
return new LazySearchEnumerationImpl(
target.doListBindings(false),
new ContainmentFilter(matchingAttributes),
cons, this, myEnv,
false); // alwaysUseFactory ignored because objReturnFlag == false
}
public NamingEnumeration search(Name name,
String filter,
SearchControls cons)
throws NamingException {
DirContext target = (DirContext) doLookup(name, false);
SearchFilter stringfilter = new SearchFilter(filter);
return new LazySearchEnumerationImpl(
new HierContextEnumerator(target,
(cons != null) ? cons.getSearchScope() :
SearchControls.ONELEVEL_SCOPE),
stringfilter,
cons, this, myEnv, alwaysUseFactory);
}
public NamingEnumeration search(Name name,
String filterExpr,
Object[] filterArgs,
SearchControls cons)
throws NamingException {
String strfilter = SearchFilter.format(filterExpr, filterArgs);
return search(name, strfilter, cons);
}
public NamingEnumeration search(String name,
String filter,
SearchControls cons)
throws NamingException {
return search(myParser.parse(name), filter, cons);
}
public NamingEnumeration search(String name,
String filterExpr,
Object[] filterArgs,
SearchControls cons)
throws NamingException {
return search(myParser.parse(name), filterExpr, filterArgs, cons);
}
// This function is called whenever a new object needs to be created.
// this is used so that if anyone subclasses us, they can override this
// and return object of their own kind.
protected HierMemDirCtx createNewCtx() throws NamingException {
return new HierMemDirCtx(myEnv, ignoreCase);
}
// If the supplied name is a composite name, return the name that
// is its first component.
protected Name canonizeName(Name name) throws NamingException {
Name canonicalName = name;
if(!(name instanceof HierarchicalName)) {
// If name is not of the correct type, make copy
canonicalName = new HierarchicalName();
int n = name.size();
for(int i = 0; i < n; i++) {
canonicalName.add(i, name.get(i));
}
}
return canonicalName;
}
protected Name getInternalName(Name name) throws NamingException {
return (name.getPrefix(name.size() - 1));
}
protected Name getLeafName(Name name) throws NamingException {
return (name.getSuffix(name.size() - 1));
}
public DirContext getSchema(String name) throws NamingException {
throw new OperationNotSupportedException();
}
public DirContext getSchema(Name name) throws NamingException {
throw new OperationNotSupportedException();
}
public DirContext getSchemaClassDefinition(String name)
throws NamingException {
throw new OperationNotSupportedException();
}
public DirContext getSchemaClassDefinition(Name name)
throws NamingException {
throw new OperationNotSupportedException();
}
// Set context in readonly mode; throw e when update operation attempted.
public void setReadOnly(NamingException e) {
readOnlyEx = e;
}
// Set context to support case-insensitive names
public void setIgnoreCase(boolean ignoreCase) {
this.ignoreCase = ignoreCase;
}
public void setNameParser(NameParser parser) {
myParser = parser;
}
// Class for enumerating name/class pairs
private class FlatNames implements NamingEnumeration {
Enumeration names;
FlatNames (Enumeration names) {
this.names = names;
}
public boolean hasMoreElements() {
try {
return hasMore();
} catch (NamingException e) {
return false;
}
}
public boolean hasMore() throws NamingException {
return names.hasMoreElements();
}
public Object nextElement() {
try {
return next();
} catch (NamingException e) {
throw new NoSuchElementException(e.toString());
}
}
public Object next() throws NamingException {
Name name = (Name)names.nextElement();
String className = bindings.get(name).getClass().getName();
return new NameClassPair(name.toString(), className);
}
public void close() {
names = null;
}
}
// Class for enumerating bindings
private final class FlatBindings extends FlatNames {
private Hashtable bds;
private Hashtable env;
private boolean useFactory;
FlatBindings(Hashtable bindings, Hashtable env, boolean useFactory) {
super(bindings.keys());
this.env = env;
this.bds = bindings;
this.useFactory = useFactory;
}
public Object next() throws NamingException {
Name name = (Name)names.nextElement();
HierMemDirCtx obj = (HierMemDirCtx)bds.get(name);
Object answer = obj;
if (useFactory) {
Attributes attrs = obj.getAttributes(""); // only method available
try {
answer = DirectoryManager.getObjectInstance(obj,
name, HierMemDirCtx.this, env, attrs);
} catch (NamingException e) {
throw e;
} catch (Exception e) {
NamingException e2 = new NamingException(
"Problem calling getObjectInstance");
e2.setRootCause(e);
throw e2;
}
}
return new Binding(name.toString(), answer);
}
}
public class HierContextEnumerator extends ContextEnumerator {
public HierContextEnumerator(Context context, int scope)
throws NamingException {
super(context, scope);
}
protected HierContextEnumerator(Context context, int scope,
String contextName, boolean returnSelf) throws NamingException {
super(context, scope, contextName, returnSelf);
}
protected NamingEnumeration getImmediateChildren(Context ctx)
throws NamingException {
return ((HierMemDirCtx)ctx).doListBindings(false);
}
protected ContextEnumerator newEnumerator(Context ctx, int scope,
String contextName, boolean returnSelf) throws NamingException {
return new HierContextEnumerator(ctx, scope, contextName,
returnSelf);
}
}
}
// CompundNames's HashCode() method isn't good enough for many string.
// The only prupose of this subclass is to have a more discerning
// hash function. We'll make up for the performance hit by caching
// the hash value.
final class HierarchicalName extends CompoundName {
private int hashValue = -1;
// Creates an empty name
HierarchicalName() {
super(new Enumeration() {
public boolean hasMoreElements() {return false;}
public Object nextElement() {throw new NoSuchElementException();}
},
HierarchicalNameParser.mySyntax);
}
HierarchicalName(Enumeration comps, Properties syntax) {
super(comps, syntax);
}
HierarchicalName(String n, Properties syntax) throws InvalidNameException {
super(n, syntax);
}
// just like String.hashCode, only it pays no attention to length
public int hashCode() {
if (hashValue == -1) {
String name = toString().toUpperCase();
int len = name.length();
int off = 0;
char val[] = new char[len];
name.getChars(0, len, val, 0);
for (int i = len; i > 0; i--) {
hashValue = (hashValue * 37) + val[off++];
}
}
return hashValue;
}
public Name getPrefix(int posn) {
Enumeration comps = super.getPrefix(posn).getAll();
return (new HierarchicalName(comps, mySyntax));
}
public Name getSuffix(int posn) {
Enumeration comps = super.getSuffix(posn).getAll();
return (new HierarchicalName(comps, mySyntax));
}
public Object clone() {
return (new HierarchicalName(getAll(), mySyntax));
}
private static final long serialVersionUID = -6717336834584573168L;
}
// This is the default name parser (used if setNameParser is not called)
final class HierarchicalNameParser implements NameParser {
static final Properties mySyntax = new Properties();
static {
mySyntax.put("jndi.syntax.direction", "left_to_right");
mySyntax.put("jndi.syntax.separator", "/");
mySyntax.put("jndi.syntax.ignorecase", "true");
mySyntax.put("jndi.syntax.escape", "\\");
mySyntax.put("jndi.syntax.beginquote", "\"");
//mySyntax.put("jndi.syntax.separator.ava", "+");
//mySyntax.put("jndi.syntax.separator.typeval", "=");
mySyntax.put("jndi.syntax.trimblanks", "false");
};
public Name parse(String name) throws NamingException {
return new HierarchicalName(name, mySyntax);
}
}