| Methods Summary |
|---|
| public void | bind(java.lang.String name, java.lang.Object obj, javax.naming.directory.Attributes attrs)Binds a name to an object, along with associated attributes. If attrs
is null, the resulting binding will have the attributes associated
with obj if obj is a DirContext, and no attributes otherwise. If attrs
is non-null, the resulting binding will have attrs as its attributes;
any attributes associated with obj are ignored.
// Note: No custom attributes allowed
File file = new File(base, name);
if (file.exists())
throw new NameAlreadyBoundException
(sm.getString("resources.alreadyBound", name));
rebind(file, obj, attrs);
|
| public javax.naming.directory.DirContext | createSubcontext(java.lang.String name, javax.naming.directory.Attributes attrs)Creates and binds a new context, along with associated attributes.
This method creates a new subcontext with the given name, binds it in
the target context (that named by all but terminal atomic component of
the name), and associates the supplied attributes with the newly
created object. All intermediate and target contexts must already
exist. If attrs is null, this method is equivalent to
Context.createSubcontext().
File file = new File(base, name);
if (file.exists())
throw new NameAlreadyBoundException
(sm.getString("resources.alreadyBound", name));
if (!file.mkdir())
throw new NamingException
(sm.getString("resources.bindFailed", name));
return (DirContext) lookup(name);
|
| public void | destroySubcontext(java.lang.String name)Destroys the named context and removes it from the namespace. Any
attributes associated with the name are also removed. Intermediate
contexts are not destroyed.
This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
In a federated naming system, a context from one naming system may be
bound to a name in another. One can subsequently look up and perform
operations on the foreign context using a composite name. However, an
attempt destroy the context using this composite name will fail with
NotContextException, because the foreign context is not a "subcontext"
of the context in which it is bound. Instead, use unbind() to remove
the binding of the foreign context. Destroying the foreign context
requires that the destroySubcontext() be performed on a context from
the foreign context's "native" naming system.
unbind(name);
|
| protected java.io.File | file(java.lang.String name)Return a File object representing the specified normalized
context-relative path if it exists and is readable. Otherwise,
return null.
// START S1AS8PE 4965170
File file = (File)fileCache.get(name);
if (file == null){
file = new File(base, name);
}
// END S1AS8PE 4965170
if (file.exists() && file.canRead()) {
// START S1AS 6200277
if (!caseSensitive && allowLinking) {
fileCache.put(name,file);
return file;
}
// END S1AS 6200277
// Check that this file belongs to our root path
String canPath = null;
try {
canPath = file.getCanonicalPath();
} catch (IOException e) {
}
if (canPath == null)
return null;
// Check to see if going outside of the web application root
if ((!allowLinking) && (!canPath.startsWith(absoluteBase))) {
return null;
}
// Case sensitivity check
// START S1AS 6200277
// if (!allowLinking && caseSensitive) {
// END S1AS 6200277
// START S1AS 6200277
if (caseSensitive) {
// END S1AS 6200277
String fileAbsPath = file.getAbsolutePath();
if (fileAbsPath.endsWith("."))
fileAbsPath = fileAbsPath + "/";
String absPath = normalize(fileAbsPath);
if (canPath != null)
canPath = normalize(canPath);
if ((absoluteBase.length() < absPath.length())
&& (absoluteBase.length() < canPath.length())) {
absPath = absPath.substring(absoluteBase.length() + 1);
if ((canPath == null) || (absPath == null))
return null;
if (absPath.equals(""))
absPath = "/";
canPath = canPath.substring(absoluteBase.length() + 1);
if (canPath.equals(""))
canPath = "/";
if (!canPath.equals(absPath)) {
// START S1AS 6200277
// return null;
// END S1AS 6200277
// START S1AS 6200277
if (canPath.equalsIgnoreCase(absPath)
|| !allowLinking) {
return null;
}
// END S1AS 6200277
}
}
}
} else {
return null;
}
// START S1AS8PE 4965170
fileCache.put(name,file);
// END S1AS8PE 4965170
return file;
|
| public boolean | getAllowLinking()Is linking allowed.
return allowLinking;
|
| public javax.naming.directory.Attributes | getAttributes(java.lang.String name, java.lang.String[] attrIds)Retrieves selected attributes associated with a named object.
See the class description regarding attribute models, attribute type
names, and operational attributes.
// Building attribute list
File file = file(name);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", name));
return new FileResourceAttributes(file);
|
| public java.lang.String | getNameInNamespace()Retrieves the full name of this context within its own namespace.
Many naming services have a notion of a "full name" for objects in
their respective namespaces. For example, an LDAP entry has a
distinguished name, and a DNS record has a fully qualified name. This
method allows the client application to retrieve this name. The string
returned by this method is not a JNDI composite name and should not be
passed directly to context methods. In naming systems for which the
notion of full name does not make sense,
OperationNotSupportedException is thrown.
return docBase;
|
| public javax.naming.directory.DirContext | getSchema(java.lang.String name)Retrieves the schema associated with the named object. The schema
describes rules regarding the structure of the namespace and the
attributes stored within it. The schema specifies what types of
objects can be added to the directory and where they can be added;
what mandatory and optional attributes an object can have. The range
of support for schemas is directory-specific.
throw new OperationNotSupportedException();
|
| public javax.naming.directory.DirContext | getSchemaClassDefinition(java.lang.String name)Retrieves a context containing the schema objects of the named
object's class definitions.
throw new OperationNotSupportedException();
|
| public boolean | isCaseSensitive()Is case sensitive ?
return caseSensitive;
|
| public javax.naming.NamingEnumeration | list(java.lang.String name)Enumerates the names bound in the named context, along with the class
names of objects bound to them. The contents of any subcontexts are
not included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
File file = file(name);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", name));
Vector entries = list(file);
return new NamingContextEnumeration(entries);
|
| protected java.util.Vector | list(java.io.File file)List the resources which are members of a collection.
Vector entries = new Vector();
if (!file.isDirectory())
return entries;
String[] names = file.list();
Arrays.sort(names); // Sort alphabetically
if (names == null)
return entries;
NamingEntry entry = null;
for (int i = 0; i < names.length; i++) {
// START S1AS8PE 4965170
File currentFile = (File)fileCache.get(names[i]);
if ( currentFile == null ) {
currentFile = new File(file, names[i]);
fileCache.put(names[i],currentFile);
}
// END S1AS8PE 4965170
Object object = null;
if (currentFile.isDirectory()) {
FileDirContext tempContext = new FileDirContext(env);
tempContext.setDocBase(file.getPath());
tempContext.setAllowLinking(getAllowLinking());
tempContext.setCaseSensitive(isCaseSensitive());
object = tempContext;
} else {
object = new FileResource(currentFile);
}
entry = new NamingEntry(names[i], object, NamingEntry.ENTRY);
entries.addElement(entry);
}
return entries;
|
| public javax.naming.NamingEnumeration | listBindings(java.lang.String name)Enumerates the names bound in the named context, along with the
objects bound to them. The contents of any subcontexts are not
included.
If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
File file = file(name);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", name));
Vector entries = list(file);
return new NamingContextBindingsEnumeration(entries);
|
| public java.lang.Object | lookup(java.lang.String name)Retrieves the named object.
Object result = null;
File file = file(name);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", name));
if (file.isDirectory()) {
FileDirContext tempContext = new FileDirContext(env);
tempContext.setDocBase(file.getPath());
tempContext.setAllowLinking(getAllowLinking());
tempContext.setCaseSensitive(isCaseSensitive());
result = tempContext;
} else {
result = new FileResource(file);
}
return result;
|
| public java.lang.Object | lookupLink(java.lang.String name)Retrieves the named object, following links except for the terminal
atomic component of the name. If the object bound to name is not a
link, returns the object itself.
// Note : Links are not supported
return lookup(name);
|
| public void | modifyAttributes(java.lang.String name, int mod_op, javax.naming.directory.Attributes attrs)Modifies the attributes associated with a named object. The order of
the modifications is not specified. Where possible, the modifications
are performed atomically.
|
| public void | modifyAttributes(java.lang.String name, javax.naming.directory.ModificationItem[] mods)Modifies the attributes associated with a named object using an an
ordered list of modifications. The modifications are performed in the
order specified. Each modification specifies a modification operation
code and an attribute on which to operate. Where possible, the
modifications are performed atomically.
|
| protected java.lang.String | normalize(java.lang.String path)Return a context-relative path, beginning with a "/", that represents
the canonical version of the specified path after ".." and "." elements
are resolved out. If the specified path attempts to go outside the
boundaries of the current context (i.e. too many ".." path elements
are present), return null instead.
String normalized = path;
// Normalize the slashes and add leading slash if necessary
if (File.separatorChar == '\\" && normalized.indexOf('\\") >= 0)
normalized = normalized.replace('\\", '/");
if (!normalized.startsWith("/"))
normalized = "/" + normalized;
// Resolve occurrences of "//" in the normalized path
while (true) {
int index = normalized.indexOf("//");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 1);
}
// Resolve occurrences of "/./" in the normalized path
while (true) {
int index = normalized.indexOf("/./");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 2);
}
// Resolve occurrences of "/../" in the normalized path
while (true) {
int index = normalized.indexOf("/../");
if (index < 0)
break;
if (index == 0)
return (null); // Trying to go outside our context
int index2 = normalized.lastIndexOf('/", index - 1);
normalized = normalized.substring(0, index2) +
normalized.substring(index + 3);
}
// Return the normalized path that we have completed
return (normalized);
|
| public void | rebind(java.lang.String name, java.lang.Object obj, javax.naming.directory.Attributes attrs)Binds a name to an object, along with associated attributes,
overwriting any existing binding. If attrs is null and obj is a
DirContext, the attributes from obj are used. If attrs is null and obj
is not a DirContext, any existing attributes associated with the object
already bound in the directory remain unchanged. If attrs is non-null,
any existing attributes associated with the object already bound in
the directory are removed and attrs is associated with the named
object. If obj is a DirContext and attrs is non-null, the attributes
of obj are ignored.
// Note: No custom attributes allowed
// Check obj type
File file = new File(base, name);
rebind(file,obj,attrs);
|
| public void | rebind(java.io.File file, java.lang.Object obj, javax.naming.directory.Attributes attrs)
InputStream is = null;
String name = file.getName();
if (obj instanceof Resource) {
try {
is = ((Resource) obj).streamContent();
} catch (IOException e) {
}
} else if (obj instanceof InputStream) {
is = (InputStream) obj;
} else if (obj instanceof DirContext) {
if (file.exists()) {
if (!file.delete())
throw new NamingException
(sm.getString("resources.bindFailed", name));
}
if (!file.mkdir())
throw new NamingException
(sm.getString("resources.bindFailed", name));
}
if (is == null)
throw new NamingException
(sm.getString("resources.bindFailed", name));
// Open os
try {
FileOutputStream os = null;
byte buffer[] = new byte[BUFFER_SIZE];
int len = -1;
try {
os = new FileOutputStream(file);
while (true) {
len = is.read(buffer);
if (len == -1)
break;
os.write(buffer, 0, len);
}
} finally {
if (os != null)
os.close();
is.close();
}
} catch (IOException e) {
throw new NamingException
(sm.getString("resources.bindFailed", e));
}
|
| public void | release()Release any resources allocated for this directory context.
caseSensitive = true;
allowLinking = false;
absoluteBase = null;
base = null;
super.release();
|
| public void | rename(java.lang.String oldName, java.lang.String newName)Binds a new name to the object bound to an old name, and unbinds the
old name. Both names are relative to this context. Any attributes
associated with the old name become associated with the new name.
Intermediate contexts of the old name are not changed.
File file = file(oldName);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", oldName));
// START S1AS8PE 4965170
File newFile = (File)fileCache.get(newName);
if (newFile == null) {
newFile = new File(base, newName);
}
// END S1AS8PE 4965170
file.renameTo(newFile);
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, javax.naming.directory.Attributes matchingAttributes, java.lang.String[] attributesToReturn)Searches in a single context for objects that contain a specified set
of attributes, and retrieves selected attributes. The search is
performed using the default SearchControls settings.
return null;
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, javax.naming.directory.Attributes matchingAttributes)Searches in a single context for objects that contain a specified set
of attributes. This method returns all the attributes of such objects.
It is equivalent to supplying null as the atributesToReturn parameter
to the method search(Name, Attributes, String[]).
return null;
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, java.lang.String filter, javax.naming.directory.SearchControls cons)Searches in the named context or object for entries that satisfy the
given search filter. Performs the search as specified by the search
controls.
return null;
|
| public javax.naming.NamingEnumeration | search(java.lang.String name, java.lang.String filterExpr, java.lang.Object[] filterArgs, javax.naming.directory.SearchControls cons)Searches in the named context or object for entries that satisfy the
given search filter. Performs the search as specified by the search
controls.
return null;
|
| public void | setAllowLinking(boolean allowLinking)Set allow linking.
this.allowLinking = allowLinking;
|
| public void | setCaseSensitive(boolean caseSensitive)Set case sensitivity.
this.caseSensitive = caseSensitive;
|
| public void | setDocBase(java.lang.String docBase)Set the document root.
// ------------------------------------------------------------- Properties
// Validate the format of the proposed document root
if (docBase == null)
throw new IllegalArgumentException
(sm.getString("resources.null"));
// START S1AS8PE 4965170
base = (File)fileCache.get(docBase);
if (base == null){
// Calculate a File object referencing this document base directory
base = new File(docBase);
fileCache.put(docBase,base);
}
// END S1AS8PE 4965170
try {
base = base.getCanonicalFile();
} catch (IOException e) {
// Ignore
}
// Validate that the document base is an existing directory
if (!base.exists() || !base.isDirectory() || !base.canRead())
throw new IllegalArgumentException
(sm.getString("fileResources.base", docBase));
this.absoluteBase = base.getAbsolutePath();
super.setDocBase(docBase);
|
| public void | unbind(java.lang.String name)Unbinds the named object. Removes the terminal atomic name in name
from the target context--that named by all but the terminal atomic
part of name.
This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
File file = file(name);
if (file == null)
throw new NamingException
(sm.getString("resources.notFound", name));
// START S1AS8PE 4965170
fileCache.remove(name);
// END S1AS8PE 4965170
if (!file.delete())
throw new NamingException
(sm.getString("resources.unbindFailed", name));
|
