ojluni/src/main/java/com/sun/jndi/rmi/registry/RegistryContext.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 1999, 2010, 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.rmi.registry;


 import java.util.Hashtable;
 import java.util.Properties;
 import java.rmi.*;
 import java.rmi.server.*;
 import java.rmi.registry.Registry;
 import java.rmi.registry.LocateRegistry;

 import javax.naming.*;
 import javax.naming.spi.NamingManager;


 /**
  * A RegistryContext is a context representing a remote RMI registry.
  *
  * @author Scott Seligman
  */


 public class RegistryContext implements Context, Referenceable {

     private Hashtable environment;
     private Registry registry;
     private String host;
     private int port;
     private static final NameParser nameParser = new AtomicNameParser();
     private static final String SOCKET_FACTORY = "com.sun.jndi.rmi.factory.socket";

     Reference reference = null; // ref used to create this context, if any

     // Environment property that, if set, indicates that a security
     // manager should be installed (if none is already in place).
     public static final String SECURITY_MGR =
             "java.naming.rmi.security.manager";

     /**
      * Returns a context for the registry at a given host and port.
      * If "host" is null, uses default host.
      * If "port" is non-positive, uses default port.
      * Cloning of "env" is handled by caller; see comments within
      * RegistryContextFactory.getObjectInstance(), for example.
      */
     public RegistryContext(String host, int port, Hashtable env)
             throws NamingException
     {
         environment = ((env == null) ? new Hashtable(5) : env);
         if (environment.get(SECURITY_MGR) != null) {
             installSecurityMgr();
         }

         // chop off '[' and ']' in an IPv6 literal address
         if ((host != null) && (host.charAt(0) == '[')) {
             host = host.substring(1, host.length() - 1);
         }

         RMIClientSocketFactory socketFactory =
                 (RMIClientSocketFactory) environment.get(SOCKET_FACTORY);
         registry = getRegistry(host, port, socketFactory);
         this.host = host;
         this.port = port;
     }

     /**
      * Returns a clone of a registry context.  The context's private state
      * is independent of the original's (so closing one context, for example,
      * won't close the other).
      */
     // %%% Alternatively, this could be done with a clone() method.
     RegistryContext(RegistryContext ctx) {
         environment = (Hashtable)ctx.environment.clone();
         registry = ctx.registry;
         host = ctx.host;
         port = ctx.port;
         reference = ctx.reference;
     }

     protected void finalize() {
         close();
     }

     public Object lookup(Name name) throws NamingException {
         if (name.isEmpty()) {
             return (new RegistryContext(this));
         }
         Remote obj;
         try {
             obj = registry.lookup(name.get(0));
         } catch (NotBoundException e) {
             throw (new NameNotFoundException(name.get(0)));
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
         return (decodeObject(obj, name.getPrefix(1)));
     }

     public Object lookup(String name) throws NamingException {
         return lookup(new CompositeName(name));
     }

     /**
      * If the object to be bound is both Remote and Referenceable, binds the
      * object itself, not its Reference.
      */
     public void bind(Name name, Object obj) throws NamingException {
         if (name.isEmpty()) {
             throw (new InvalidNameException(
                     "RegistryContext: Cannot bind empty name"));
         }
         try {
             registry.bind(name.get(0), encodeObject(obj, name.getPrefix(1)));
         } catch (AlreadyBoundException e) {
             NamingException ne = new NameAlreadyBoundException(name.get(0));
             ne.setRootCause(e);
             throw ne;
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     public void bind(String name, Object obj) throws NamingException {
         bind(new CompositeName(name), obj);
     }

     public void rebind(Name name, Object obj) throws NamingException {
         if (name.isEmpty()) {
             throw (new InvalidNameException(
                     "RegistryContext: Cannot rebind empty name"));
         }
         try {
             registry.rebind(name.get(0), encodeObject(obj, name.getPrefix(1)));
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     public void rebind(String name, Object obj) throws NamingException {
         rebind(new CompositeName(name), obj);
     }

     public void unbind(Name name) throws NamingException {
         if (name.isEmpty()) {
             throw (new InvalidNameException(
                     "RegistryContext: Cannot unbind empty name"));
         }
         try {
             registry.unbind(name.get(0));
         } catch (NotBoundException e) {
             // method is idempotent
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     public void unbind(String name) throws NamingException {
         unbind(new CompositeName(name));
     }

     /**
      * Rename is implemented by this sequence of operations:
      * lookup, bind, unbind.  The sequence is not performed atomically.
      */
     public void rename(Name oldName, Name newName) throws NamingException {
         bind(newName, lookup(oldName));
         unbind(oldName);
     }

     public void rename(String name, String newName) throws NamingException {
         rename(new CompositeName(name), new CompositeName(newName));
     }

     public NamingEnumeration list(Name name)    throws NamingException {
         if (!name.isEmpty()) {
             throw (new InvalidNameException(
                     "RegistryContext: can only list \"\""));
         }
         try {
             String[] names = registry.list();
             return (new NameClassPairEnumeration(names));
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     public NamingEnumeration list(String name) throws NamingException {
         return list(new CompositeName(name));
     }

     public NamingEnumeration listBindings(Name name)
             throws NamingException
     {
         if (!name.isEmpty()) {
             throw (new InvalidNameException(
                     "RegistryContext: can only list \"\""));
         }
         try {
             String[] names = registry.list();
             return (new BindingEnumeration(this, names));
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     public NamingEnumeration listBindings(String name) throws NamingException {
         return listBindings(new CompositeName(name));
     }

     public void destroySubcontext(Name name) throws NamingException {
         throw (new OperationNotSupportedException());
     }

     public void destroySubcontext(String name) throws NamingException {
         throw (new OperationNotSupportedException());
     }

     public Context createSubcontext(Name name) throws NamingException {
         throw (new OperationNotSupportedException());
     }

     public Context createSubcontext(String name) throws NamingException {
         throw (new OperationNotSupportedException());
     }

     public Object lookupLink(Name name) throws NamingException {
         return lookup(name);
     }

     public Object lookupLink(String name) throws NamingException {
         return lookup(name);
     }

     public NameParser getNameParser(Name name) throws NamingException {
         return nameParser;
     }

     public NameParser getNameParser(String name) throws NamingException {
         return nameParser;
     }

     public Name composeName(Name name, Name prefix) throws NamingException {
         Name result = (Name)prefix.clone();
         return result.addAll(name);
     }

     public String composeName(String name, String prefix)
             throws NamingException
     {
         return composeName(new CompositeName(name),
                            new CompositeName(prefix)).toString();
     }

     public Object removeFromEnvironment(String propName)
             throws NamingException
     {
         return environment.remove(propName);
     }

     public Object addToEnvironment(String propName, Object propVal)
             throws NamingException
     {
         if (propName.equals(SECURITY_MGR)) {
             installSecurityMgr();
         }
         return environment.put(propName, propVal);
     }

     public Hashtable getEnvironment() throws NamingException {
         return (Hashtable)environment.clone();
     }

     public void close() {
         environment = null;
         registry = null;
         // &&& If we were caching registry connections, we would probably
         // uncache this one now.
     }

     public String getNameInNamespace() {
         return ""; // Registry has an empty name
     }

     /**
      * Returns an RMI registry reference for this context.
      *<p>
      * If this context was created from a reference, that reference is
      * returned.  Otherwise, an exception is thrown if the registry's
      * host is "localhost" or the default (null).  Although this could
      * possibly make for a valid reference, it's far more likely to be
      * an easily made error.
      *
      * @see RegistryContextFactory
      */
     public Reference getReference() throws NamingException {
         if (reference != null) {
             return (Reference)reference.clone();  // %%% clone the addrs too?
         }
         if (host == null || host.equals("localhost")) {
             throw (new ConfigurationException(
                     "Cannot create a reference for an RMI registry whose " +
                     "host was unspecified or specified as \"localhost\""));
         }
         String url = "rmi://";

         // Enclose IPv6 literal address in '[' and ']'
         url = (host.indexOf(":") > -1) ? url + "[" + host + "]" :
                                          url + host;
         if (port > 0) {
             url += ":" + Integer.toString(port);
         }
         RefAddr addr = new StringRefAddr(RegistryContextFactory.ADDRESS_TYPE,
                                          url);
         return (new Reference(RegistryContext.class.getName(),
                               addr,
                               RegistryContextFactory.class.getName(),
                               null));
     }


     /**
      * Wrap a RemoteException inside a NamingException.
      */
     public static NamingException wrapRemoteException(RemoteException re) {

         NamingException ne;

         if (re instanceof ConnectException) {
             ne = new ServiceUnavailableException();

         } else if (re instanceof AccessException) {
             ne = new NoPermissionException();

         } else if (re instanceof StubNotFoundException ||
                    re instanceof UnknownHostException ||
                    re instanceof SocketSecurityException) {
             ne = new ConfigurationException();

         } else if (re instanceof ExportException ||
                    re instanceof ConnectIOException ||
                    re instanceof MarshalException ||
                    re instanceof UnmarshalException ||
                    re instanceof NoSuchObjectException) {
             ne = new CommunicationException();

         } else if (re instanceof ServerException &&
                    re.detail instanceof RemoteException) {
             ne = wrapRemoteException((RemoteException)re.detail);

         } else {
             ne = new NamingException();
         }
         ne.setRootCause(re);
         return ne;
     }

     /**
      * Returns the registry at a given host, port and socket factory.
      * If "host" is null, uses default host.
      * If "port" is non-positive, uses default port.
      * If "socketFactory" is null, uses the default socket.
      */
     private static Registry getRegistry(String host, int port,
                 RMIClientSocketFactory socketFactory)
             throws NamingException
     {
         // %%% We could cache registry connections here.  The transport layer
         // may already reuse connections.
         try {
             if (socketFactory == null) {
                 return LocateRegistry.getRegistry(host, port);
             } else {
                 return LocateRegistry.getRegistry(host, port, socketFactory);
             }
         } catch (RemoteException e) {
             throw (NamingException)wrapRemoteException(e).fillInStackTrace();
         }
     }

     /**
      * Attempts to install a security manager if none is currently in
      * place.
      */
     private static void installSecurityMgr() {

         try {
             System.setSecurityManager(new RMISecurityManager());
         } catch (Exception e) {
         }
     }

     /**
      * Encodes an object prior to binding it in the registry.  First,
      * NamingManager.getStateToBind() is invoked.  If the resulting
      * object is Remote, it is returned.  If it is a Reference or
      * Referenceable, the reference is wrapped in a Remote object.
      * Otherwise, an exception is thrown.
      *
      * @param name      The object's name relative to this context.
      */
     private Remote encodeObject(Object obj, Name name)
             throws NamingException, RemoteException
     {
         obj = NamingManager.getStateToBind(obj, name, this, environment);

         if (obj instanceof Remote) {
             return (Remote)obj;
         }
         if (obj instanceof Reference) {
             return (new ReferenceWrapper((Reference)obj));
         }
         if (obj instanceof Referenceable) {
             return (new ReferenceWrapper(((Referenceable)obj).getReference()));
         }
         throw (new IllegalArgumentException(
                 "RegistryContext: " +
                 "object to bind must be Remote, Reference, or Referenceable"));
     }

     /**
      * Decodes an object that has been retrieved from the registry.
      * First, if the object is a RemoteReference, the Reference is
      * unwrapped.  Then, NamingManager.getObjectInstance() is invoked.
      *
      * @param name      The object's name relative to this context.
      */
     private Object decodeObject(Remote r, Name name) throws NamingException {
         try {
             Object obj = (r instanceof RemoteReference)
                         ? ((RemoteReference)r).getReference()
                         : (Object)r;
             return NamingManager.getObjectInstance(obj, name, this,
                                                    environment);
         } catch (NamingException e) {
             throw e;
         } catch (RemoteException e) {
             throw (NamingException)
                 wrapRemoteException(e).fillInStackTrace();
         } catch (Exception e) {
             NamingException ne = new NamingException();
             ne.setRootCause(e);
             throw ne;
         }
     }

 }


 /**
  * A name parser for case-sensitive atomic names.
  */
 class AtomicNameParser implements NameParser {
     private static final Properties syntax = new Properties();

     public Name parse(String name) throws NamingException {
         return (new CompoundName(name, syntax));
     }
 }


 /**
  * An enumeration of name / class-name pairs.  Since we don't know anything
  * about the classes, each class name is returned as the generic
  * "java.lang.Object".
  */
 class NameClassPairEnumeration implements NamingEnumeration {
     private final String[] names;
     private int nextName;       // index into "names"

     NameClassPairEnumeration(String[] names) {
         this.names = names;
         nextName = 0;
     }

     public boolean hasMore() {
         return (nextName < names.length);
     }

     public Object next() throws NamingException {
         if (!hasMore()) {
             throw (new java.util.NoSuchElementException());
         }
         // Convert name to a one-element composite name, so embedded
         // meta-characters are properly escaped.
         String name = names[nextName++];
         Name cname = (new CompositeName()).add(name);
         NameClassPair ncp = new NameClassPair(cname.toString(),
                                             "java.lang.Object");
         ncp.setNameInNamespace(name);
         return ncp;
     }

     public boolean hasMoreElements() {
         return hasMore();
     }

     public Object nextElement() {
         try {
             return next();
         } catch (NamingException e) {   // should never happen
             throw (new java.util.NoSuchElementException(
                     "javax.naming.NamingException was thrown"));
         }
     }

     public void close() {
         nextName = names.length;
     }
 }


 /**
  * An enumeration of Bindings.
  *
  * The actual registry lookups are performed when next() is called.  It would
  * be nicer to defer this until the object (or its class name) is actually
  * requested.  The problem with that approach is that Binding.getObject()
  * cannot throw NamingException.
  */
 class BindingEnumeration implements NamingEnumeration {
     private RegistryContext ctx;
     private final String[] names;
     private int nextName;       // index into "names"

     BindingEnumeration(RegistryContext ctx, String[] names) {
         // Clone ctx in case someone closes it before we're through.
         this.ctx = new RegistryContext(ctx);
         this.names = names;
         nextName = 0;
     }

     protected void finalize() {
         ctx.close();
     }

     public boolean hasMore() {
         if (nextName >= names.length) {
             ctx.close();
         }
         return (nextName < names.length);
     }

     public Object next() throws NamingException {
         if (!hasMore()) {
             throw (new java.util.NoSuchElementException());
         }
         // Convert name to a one-element composite name, so embedded
         // meta-characters are properly escaped.
         String name = names[nextName++];
         Name cname = (new CompositeName()).add(name);

         Object obj = ctx.lookup(cname);
         String cnameStr = cname.toString();
         Binding binding = new Binding(cnameStr, obj);
         binding.setNameInNamespace(cnameStr);
         return binding;
     }

     public boolean hasMoreElements() {
         return hasMore();
     }

     public Object nextElement() {
         try {
             return next();
         } catch (NamingException e) {
             throw (new java.util.NoSuchElementException(
                     "javax.naming.NamingException was thrown"));
         }
     }

     public void close () {
         finalize();
     }
 }
	/*
	* Copyright (c) 1999, 2010, 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.rmi.registry;


	import java.util.Hashtable;
	import java.util.Properties;
	import java.rmi.*;
	import java.rmi.server.*;
	import java.rmi.registry.Registry;
	import java.rmi.registry.LocateRegistry;

	import javax.naming.*;
	import javax.naming.spi.NamingManager;


	/**
	* A RegistryContext is a context representing a remote RMI registry.
	*
	* @author Scott Seligman
	*/


	public class RegistryContext implements Context, Referenceable {

	private Hashtable environment;
	private Registry registry;
	private String host;
	private int port;
	private static final NameParser nameParser = new AtomicNameParser();
	private static final String SOCKET_FACTORY = "com.sun.jndi.rmi.factory.socket";

	Reference reference = null; // ref used to create this context, if any

	// Environment property that, if set, indicates that a security
	// manager should be installed (if none is already in place).
	public static final String SECURITY_MGR =
	"java.naming.rmi.security.manager";

	/**
	* Returns a context for the registry at a given host and port.
	* If "host" is null, uses default host.
	* If "port" is non-positive, uses default port.
	* Cloning of "env" is handled by caller; see comments within
	* RegistryContextFactory.getObjectInstance(), for example.
	*/
	public RegistryContext(String host, int port, Hashtable env)
	throws NamingException
	{
	environment = ((env == null) ? new Hashtable(5) : env);
	if (environment.get(SECURITY_MGR) != null) {
	installSecurityMgr();
	}

	// chop off '[' and ']' in an IPv6 literal address
	if ((host != null) && (host.charAt(0) == '[')) {
	host = host.substring(1, host.length() - 1);
	}

	RMIClientSocketFactory socketFactory =
	(RMIClientSocketFactory) environment.get(SOCKET_FACTORY);
	registry = getRegistry(host, port, socketFactory);
	this.host = host;
	this.port = port;
	}

	/**
	* Returns a clone of a registry context. The context's private state
	* is independent of the original's (so closing one context, for example,
	* won't close the other).
	*/
	// %%% Alternatively, this could be done with a clone() method.
	RegistryContext(RegistryContext ctx) {
	environment = (Hashtable)ctx.environment.clone();
	registry = ctx.registry;
	host = ctx.host;
	port = ctx.port;
	reference = ctx.reference;
	}

	protected void finalize() {
	close();
	}

	public Object lookup(Name name) throws NamingException {
	if (name.isEmpty()) {
	return (new RegistryContext(this));
	}
	Remote obj;
	try {
	obj = registry.lookup(name.get(0));
	} catch (NotBoundException e) {
	throw (new NameNotFoundException(name.get(0)));
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	return (decodeObject(obj, name.getPrefix(1)));
	}

	public Object lookup(String name) throws NamingException {
	return lookup(new CompositeName(name));
	}

	/**
	* If the object to be bound is both Remote and Referenceable, binds the
	* object itself, not its Reference.
	*/
	public void bind(Name name, Object obj) throws NamingException {
	if (name.isEmpty()) {
	throw (new InvalidNameException(
	"RegistryContext: Cannot bind empty name"));
	}
	try {
	registry.bind(name.get(0), encodeObject(obj, name.getPrefix(1)));
	} catch (AlreadyBoundException e) {
	NamingException ne = new NameAlreadyBoundException(name.get(0));
	ne.setRootCause(e);
	throw ne;
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	public void bind(String name, Object obj) throws NamingException {
	bind(new CompositeName(name), obj);
	}

	public void rebind(Name name, Object obj) throws NamingException {
	if (name.isEmpty()) {
	throw (new InvalidNameException(
	"RegistryContext: Cannot rebind empty name"));
	}
	try {
	registry.rebind(name.get(0), encodeObject(obj, name.getPrefix(1)));
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	public void rebind(String name, Object obj) throws NamingException {
	rebind(new CompositeName(name), obj);
	}

	public void unbind(Name name) throws NamingException {
	if (name.isEmpty()) {
	throw (new InvalidNameException(
	"RegistryContext: Cannot unbind empty name"));
	}
	try {
	registry.unbind(name.get(0));
	} catch (NotBoundException e) {
	// method is idempotent
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	public void unbind(String name) throws NamingException {
	unbind(new CompositeName(name));
	}

	/**
	* Rename is implemented by this sequence of operations:
	* lookup, bind, unbind. The sequence is not performed atomically.
	*/
	public void rename(Name oldName, Name newName) throws NamingException {
	bind(newName, lookup(oldName));
	unbind(oldName);
	}

	public void rename(String name, String newName) throws NamingException {
	rename(new CompositeName(name), new CompositeName(newName));
	}

	public NamingEnumeration list(Name name) throws NamingException {
	if (!name.isEmpty()) {
	throw (new InvalidNameException(
	"RegistryContext: can only list \"\""));
	}
	try {
	String[] names = registry.list();
	return (new NameClassPairEnumeration(names));
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	public NamingEnumeration list(String name) throws NamingException {
	return list(new CompositeName(name));
	}

	public NamingEnumeration listBindings(Name name)
	throws NamingException
	{
	if (!name.isEmpty()) {
	throw (new InvalidNameException(
	"RegistryContext: can only list \"\""));
	}
	try {
	String[] names = registry.list();
	return (new BindingEnumeration(this, names));
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	public NamingEnumeration listBindings(String name) throws NamingException {
	return listBindings(new CompositeName(name));
	}

	public void destroySubcontext(Name name) throws NamingException {
	throw (new OperationNotSupportedException());
	}

	public void destroySubcontext(String name) throws NamingException {
	throw (new OperationNotSupportedException());
	}

	public Context createSubcontext(Name name) throws NamingException {
	throw (new OperationNotSupportedException());
	}

	public Context createSubcontext(String name) throws NamingException {
	throw (new OperationNotSupportedException());
	}

	public Object lookupLink(Name name) throws NamingException {
	return lookup(name);
	}

	public Object lookupLink(String name) throws NamingException {
	return lookup(name);
	}

	public NameParser getNameParser(Name name) throws NamingException {
	return nameParser;
	}

	public NameParser getNameParser(String name) throws NamingException {
	return nameParser;
	}

	public Name composeName(Name name, Name prefix) throws NamingException {
	Name result = (Name)prefix.clone();
	return result.addAll(name);
	}

	public String composeName(String name, String prefix)
	throws NamingException
	{
	return composeName(new CompositeName(name),
	new CompositeName(prefix)).toString();
	}

	public Object removeFromEnvironment(String propName)
	throws NamingException
	{
	return environment.remove(propName);
	}

	public Object addToEnvironment(String propName, Object propVal)
	throws NamingException
	{
	if (propName.equals(SECURITY_MGR)) {
	installSecurityMgr();
	}
	return environment.put(propName, propVal);
	}

	public Hashtable getEnvironment() throws NamingException {
	return (Hashtable)environment.clone();
	}

	public void close() {
	environment = null;
	registry = null;
	// &&& If we were caching registry connections, we would probably
	// uncache this one now.
	}

	public String getNameInNamespace() {
	return ""; // Registry has an empty name
	}

	/**
	* Returns an RMI registry reference for this context.
	*<p>
	* If this context was created from a reference, that reference is
	* returned. Otherwise, an exception is thrown if the registry's
	* host is "localhost" or the default (null). Although this could
	* possibly make for a valid reference, it's far more likely to be
	* an easily made error.
	*
	* @see RegistryContextFactory
	*/
	public Reference getReference() throws NamingException {
	if (reference != null) {
	return (Reference)reference.clone(); // %%% clone the addrs too?
	}
	if (host == null \|\| host.equals("localhost")) {
	throw (new ConfigurationException(
	"Cannot create a reference for an RMI registry whose " +
	"host was unspecified or specified as \"localhost\""));
	}
	String url = "rmi://";

	// Enclose IPv6 literal address in '[' and ']'
	url = (host.indexOf(":") > -1) ? url + "[" + host + "]" :
	url + host;
	if (port > 0) {
	url += ":" + Integer.toString(port);
	}
	RefAddr addr = new StringRefAddr(RegistryContextFactory.ADDRESS_TYPE,
	url);
	return (new Reference(RegistryContext.class.getName(),
	addr,
	RegistryContextFactory.class.getName(),
	null));
	}


	/**
	* Wrap a RemoteException inside a NamingException.
	*/
	public static NamingException wrapRemoteException(RemoteException re) {

	NamingException ne;

	if (re instanceof ConnectException) {
	ne = new ServiceUnavailableException();

	} else if (re instanceof AccessException) {
	ne = new NoPermissionException();

	} else if (re instanceof StubNotFoundException \|\|
	re instanceof UnknownHostException \|\|
	re instanceof SocketSecurityException) {
	ne = new ConfigurationException();

	} else if (re instanceof ExportException \|\|
	re instanceof ConnectIOException \|\|
	re instanceof MarshalException \|\|
	re instanceof UnmarshalException \|\|
	re instanceof NoSuchObjectException) {
	ne = new CommunicationException();

	} else if (re instanceof ServerException &&
	re.detail instanceof RemoteException) {
	ne = wrapRemoteException((RemoteException)re.detail);

	} else {
	ne = new NamingException();
	}
	ne.setRootCause(re);
	return ne;
	}

	/**
	* Returns the registry at a given host, port and socket factory.
	* If "host" is null, uses default host.
	* If "port" is non-positive, uses default port.
	* If "socketFactory" is null, uses the default socket.
	*/
	private static Registry getRegistry(String host, int port,
	RMIClientSocketFactory socketFactory)
	throws NamingException
	{
	// %%% We could cache registry connections here. The transport layer
	// may already reuse connections.
	try {
	if (socketFactory == null) {
	return LocateRegistry.getRegistry(host, port);
	} else {
	return LocateRegistry.getRegistry(host, port, socketFactory);
	}
	} catch (RemoteException e) {
	throw (NamingException)wrapRemoteException(e).fillInStackTrace();
	}
	}

	/**
	* Attempts to install a security manager if none is currently in
	* place.
	*/
	private static void installSecurityMgr() {

	try {
	System.setSecurityManager(new RMISecurityManager());
	} catch (Exception e) {
	}
	}

	/**
	* Encodes an object prior to binding it in the registry. First,
	* NamingManager.getStateToBind() is invoked. If the resulting
	* object is Remote, it is returned. If it is a Reference or
	* Referenceable, the reference is wrapped in a Remote object.
	* Otherwise, an exception is thrown.
	*
	* @param name The object's name relative to this context.
	*/
	private Remote encodeObject(Object obj, Name name)
	throws NamingException, RemoteException
	{
	obj = NamingManager.getStateToBind(obj, name, this, environment);

	if (obj instanceof Remote) {
	return (Remote)obj;
	}
	if (obj instanceof Reference) {
	return (new ReferenceWrapper((Reference)obj));
	}
	if (obj instanceof Referenceable) {
	return (new ReferenceWrapper(((Referenceable)obj).getReference()));
	}
	throw (new IllegalArgumentException(
	"RegistryContext: " +
	"object to bind must be Remote, Reference, or Referenceable"));
	}

	/**
	* Decodes an object that has been retrieved from the registry.
	* First, if the object is a RemoteReference, the Reference is
	* unwrapped. Then, NamingManager.getObjectInstance() is invoked.
	*
	* @param name The object's name relative to this context.
	*/
	private Object decodeObject(Remote r, Name name) throws NamingException {
	try {
	Object obj = (r instanceof RemoteReference)
	? ((RemoteReference)r).getReference()
	: (Object)r;
	return NamingManager.getObjectInstance(obj, name, this,
	environment);
	} catch (NamingException e) {
	throw e;
	} catch (RemoteException e) {
	throw (NamingException)
	wrapRemoteException(e).fillInStackTrace();
	} catch (Exception e) {
	NamingException ne = new NamingException();
	ne.setRootCause(e);
	throw ne;
	}
	}

	}


	/**
	* A name parser for case-sensitive atomic names.
	*/
	class AtomicNameParser implements NameParser {
	private static final Properties syntax = new Properties();

	public Name parse(String name) throws NamingException {
	return (new CompoundName(name, syntax));
	}
	}


	/**
	* An enumeration of name / class-name pairs. Since we don't know anything
	* about the classes, each class name is returned as the generic
	* "java.lang.Object".
	*/
	class NameClassPairEnumeration implements NamingEnumeration {
	private final String[] names;
	private int nextName; // index into "names"

	NameClassPairEnumeration(String[] names) {
	this.names = names;
	nextName = 0;
	}

	public boolean hasMore() {
	return (nextName < names.length);
	}

	public Object next() throws NamingException {
	if (!hasMore()) {
	throw (new java.util.NoSuchElementException());
	}
	// Convert name to a one-element composite name, so embedded
	// meta-characters are properly escaped.
	String name = names[nextName++];
	Name cname = (new CompositeName()).add(name);
	NameClassPair ncp = new NameClassPair(cname.toString(),
	"java.lang.Object");
	ncp.setNameInNamespace(name);
	return ncp;
	}

	public boolean hasMoreElements() {
	return hasMore();
	}

	public Object nextElement() {
	try {
	return next();
	} catch (NamingException e) { // should never happen
	throw (new java.util.NoSuchElementException(
	"javax.naming.NamingException was thrown"));
	}
	}

	public void close() {
	nextName = names.length;
	}
	}


	/**
	* An enumeration of Bindings.
	*
	* The actual registry lookups are performed when next() is called. It would
	* be nicer to defer this until the object (or its class name) is actually
	* requested. The problem with that approach is that Binding.getObject()
	* cannot throw NamingException.
	*/
	class BindingEnumeration implements NamingEnumeration {
	private RegistryContext ctx;
	private final String[] names;
	private int nextName; // index into "names"

	BindingEnumeration(RegistryContext ctx, String[] names) {
	// Clone ctx in case someone closes it before we're through.
	this.ctx = new RegistryContext(ctx);
	this.names = names;
	nextName = 0;
	}

	protected void finalize() {
	ctx.close();
	}

	public boolean hasMore() {
	if (nextName >= names.length) {
	ctx.close();
	}
	return (nextName < names.length);
	}

	public Object next() throws NamingException {
	if (!hasMore()) {
	throw (new java.util.NoSuchElementException());
	}
	// Convert name to a one-element composite name, so embedded
	// meta-characters are properly escaped.
	String name = names[nextName++];
	Name cname = (new CompositeName()).add(name);

	Object obj = ctx.lookup(cname);
	String cnameStr = cname.toString();
	Binding binding = new Binding(cnameStr, obj);
	binding.setNameInNamespace(cnameStr);
	return binding;
	}

	public boolean hasMoreElements() {
	return hasMore();
	}

	public Object nextElement() {
	try {
	return next();
	} catch (NamingException e) {
	throw (new java.util.NoSuchElementException(
	"javax.naming.NamingException was thrown"));
	}
	}

	public void close () {
	finalize();
	}
	}