| /* |
| * Copyright (c) 1999, 2012, 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.cosnaming; |
| |
| import javax.naming.*; |
| import javax.naming.spi.NamingManager; |
| import javax.naming.spi.ResolveResult; |
| |
| import java.util.Hashtable; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| import org.omg.CosNaming.*; |
| import org.omg.CosNaming.NamingContextPackage.*; |
| import org.omg.CORBA.*; |
| |
| import com.sun.jndi.toolkit.corba.CorbaUtils; |
| |
| // Needed for creating default ORB |
| import java.applet.Applet; |
| |
| /** |
| * Provides a bridge to the CosNaming server provided by |
| * JavaIDL. This class provides the InitialContext from CosNaming. |
| * |
| * @author Raj Krishnamurthy |
| * @author Rosanna Lee |
| */ |
| |
| public class CNCtx implements javax.naming.Context { |
| |
| private final static boolean debug = false; |
| |
| /* |
| * Implement one shared ORB among all CNCtx. However, there is a public constructor |
| * accepting an ORB, so we need the option of using a given ORB. |
| */ |
| private static ORB _defaultOrb; |
| ORB _orb; // used by ExceptionMapper and RMI/IIOP factory |
| public NamingContext _nc; // public for accessing underlying NamingContext |
| |
| private synchronized static ORB getDefaultOrb() { |
| if (_defaultOrb == null) { |
| _defaultOrb = CorbaUtils.getOrb(null, -1, |
| new Hashtable<String, java.lang.Object>()); |
| } |
| return _defaultOrb; |
| } |
| |
| private NameComponent[] _name = null; |
| |
| Hashtable<String, java.lang.Object> _env; // used by ExceptionMapper |
| static final CNNameParser parser = new CNNameParser(); |
| |
| private static final String FED_PROP = "com.sun.jndi.cosnaming.federation"; |
| boolean federation = false; |
| |
| /** |
| * Determines whether classes may be loaded from an arbitrary URL code base. |
| */ |
| public static final boolean trustURLCodebase; |
| static { |
| // System property to control whether classes may be loaded from an |
| // arbitrary URL code base |
| PrivilegedAction<String> act = () -> System.getProperty( |
| "com.sun.jndi.cosnaming.object.trustURLCodebase", "false"); |
| String trust = AccessController.doPrivileged(act); |
| trustURLCodebase = "true".equalsIgnoreCase(trust); |
| } |
| |
| // Reference counter for tracking _orb references |
| OrbReuseTracker orbTracker = null; |
| int enumCount; |
| boolean isCloseCalled = false; |
| |
| /** |
| * Create a CNCtx object. Gets the initial naming |
| * reference for the COS Naming Service from the ORB. |
| * The ORB can be passed in via the java.naming.corba.orb property |
| * or be created using properties in the environment properties. |
| * @param env Environment properties for initializing name service. |
| * @exception NamingException Cannot initialize ORB or naming context. |
| */ |
| @SuppressWarnings("unchecked") |
| CNCtx(Hashtable<?,?> env) throws NamingException { |
| if (env != null) { |
| env = (Hashtable<?,?>)env.clone(); |
| } |
| _env = (Hashtable<String, java.lang.Object>)env; |
| federation = "true".equals(env != null ? env.get(FED_PROP) : null); |
| initOrbAndRootContext(env); |
| } |
| |
| private CNCtx() { |
| } |
| |
| /** |
| * This method is used by the iiop and iiopname URL Context factories. |
| */ |
| @SuppressWarnings("unchecked") |
| public static ResolveResult createUsingURL(String url, Hashtable<?,?> env) |
| throws NamingException { |
| CNCtx ctx = new CNCtx(); |
| if (env != null) { |
| env = (Hashtable<?,?>) env.clone(); |
| } |
| ctx._env = (Hashtable<String, java.lang.Object>)env; |
| String rest = ctx.initUsingUrl( |
| env != null ? |
| (org.omg.CORBA.ORB) env.get("java.naming.corba.orb") |
| : null, |
| url, env); |
| |
| // rest is the INS name |
| // Return the parsed form to prevent subsequent lookup |
| // from parsing the string as a composite name |
| // The caller should be aware that a toString() of the name, |
| // which came from the environment will yield its INS syntax, |
| // rather than a composite syntax |
| return new ResolveResult(ctx, parser.parse(rest)); |
| } |
| |
| /** |
| * Creates a CNCtx object which supports the javax.naming |
| * apis given a COS Naming Context object. |
| * @param orb The ORB used by this context |
| * @param tracker The ORB reuse tracker for tracking references to the |
| * orb object |
| * @param nctx The COS NamingContext object associated with this context |
| * @param name The name of this context relative to the root |
| */ |
| |
| CNCtx(ORB orb, OrbReuseTracker tracker, NamingContext nctx, |
| Hashtable<String, java.lang.Object> env, NameComponent[]name) |
| throws NamingException { |
| if (orb == null || nctx == null) |
| throw new ConfigurationException( |
| "Must supply ORB or NamingContext"); |
| if (orb != null) { |
| _orb = orb; |
| } else { |
| _orb = getDefaultOrb(); |
| } |
| _nc = nctx; |
| _env = env; |
| _name = name; |
| federation = "true".equals(env != null ? env.get(FED_PROP) : null); |
| } |
| |
| NameComponent[] makeFullName(NameComponent[] child) { |
| if (_name == null || _name.length == 0) { |
| return child; |
| } |
| NameComponent[] answer = new NameComponent[_name.length+child.length]; |
| |
| // parent |
| System.arraycopy(_name, 0, answer, 0, _name.length); |
| |
| // child |
| System.arraycopy(child, 0, answer, _name.length, child.length); |
| return answer; |
| } |
| |
| |
| public String getNameInNamespace() throws NamingException { |
| if (_name == null || _name.length == 0) { |
| return ""; |
| } |
| return CNNameParser.cosNameToInsString(_name); |
| } |
| |
| /** |
| * These are the URL schemes that need to be processed. |
| * IOR and corbaloc URLs can be passed directly to ORB.string_to_object() |
| */ |
| private static boolean isCorbaUrl(String url) { |
| return url.startsWith("iiop://") |
| || url.startsWith("iiopname://") |
| || url.startsWith("corbaname:") |
| ; |
| } |
| |
| /** |
| * Initializes the COS Naming Service. |
| * This method initializes the three instance fields: |
| * _nc : The root naming context. |
| * _orb: The ORB to use for connecting RMI/IIOP stubs and for |
| * getting the naming context (_nc) if one was not specified |
| * explicitly via PROVIDER_URL. |
| * _name: The name of the root naming context. |
| *<p> |
| * _orb is obtained from java.naming.corba.orb if it has been set. |
| * Otherwise, _orb is created using the host/port from PROVIDER_URL |
| * (if it contains an "iiop" or "iiopname" URL), or from initialization |
| * properties specified in env. |
| *<p> |
| * _nc is obtained from the IOR stored in PROVIDER_URL if it has been |
| * set and does not contain an "iiop" or "iiopname" URL. It can be |
| * a stringified IOR, "corbaloc" URL, "corbaname" URL, |
| * or a URL (such as file/http/ftp) to a location |
| * containing a stringified IOR. If PROVIDER_URL has not been |
| * set in this way, it is obtained from the result of |
| * ORB.resolve_initial_reference("NameService"); |
| *<p> |
| * _name is obtained from the "iiop", "iiopname", or "corbaname" URL. |
| * It is the empty name by default. |
| * |
| * @param env Environment The possibly null environment. |
| * @exception NamingException When an error occurs while initializing the |
| * ORB or the naming context. |
| */ |
| private void initOrbAndRootContext(Hashtable<?,?> env) throws NamingException { |
| org.omg.CORBA.ORB inOrb = null; |
| String ncIor = null; |
| |
| if (inOrb == null && env != null) { |
| inOrb = (org.omg.CORBA.ORB) env.get("java.naming.corba.orb"); |
| } |
| |
| if (inOrb == null) |
| inOrb = getDefaultOrb(); // will create a default ORB if none exists |
| |
| // Extract PROVIDER_URL from environment |
| String provUrl = null; |
| if (env != null) { |
| provUrl = (String)env.get(javax.naming.Context.PROVIDER_URL); |
| } |
| |
| if (provUrl != null && !isCorbaUrl(provUrl)) { |
| // Initialize the root naming context by using the IOR supplied |
| // in the PROVIDER_URL |
| ncIor = getStringifiedIor(provUrl); |
| setOrbAndRootContext(inOrb, ncIor); |
| } else if (provUrl != null) { |
| // Initialize the root naming context by using the URL supplied |
| // in the PROVIDER_URL |
| String insName = initUsingUrl(inOrb, provUrl, env); |
| |
| // If name supplied in URL, resolve it to a NamingContext |
| if (insName.length() > 0) { |
| _name = CNNameParser.nameToCosName(parser.parse(insName)); |
| try { |
| org.omg.CORBA.Object obj = _nc.resolve(_name); |
| _nc = NamingContextHelper.narrow(obj); |
| if (_nc == null) { |
| throw new ConfigurationException(insName + |
| " does not name a NamingContext"); |
| } |
| } catch (org.omg.CORBA.BAD_PARAM e) { |
| throw new ConfigurationException(insName + |
| " does not name a NamingContext"); |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, _name); |
| } |
| } |
| } else { |
| // No PROVIDER_URL supplied; initialize using defaults |
| if (debug) { |
| System.err.println("Getting default ORB: " + inOrb + env); |
| } |
| setOrbAndRootContext(inOrb, (String)null); |
| } |
| } |
| |
| |
| private String initUsingUrl(ORB orb, String url, Hashtable<?,?> env) |
| throws NamingException { |
| if (url.startsWith("iiop://") || url.startsWith("iiopname://")) { |
| return initUsingIiopUrl(orb, url, env); |
| } else { |
| return initUsingCorbanameUrl(orb, url, env); |
| } |
| } |
| |
| /** |
| * Handles "iiop" and "iiopname" URLs (INS 98-10-11) |
| */ |
| private String initUsingIiopUrl(ORB defOrb, String url, Hashtable<?,?> env) |
| throws NamingException { |
| |
| if (defOrb == null) |
| defOrb = getDefaultOrb(); |
| |
| try { |
| IiopUrl parsedUrl = new IiopUrl(url); |
| |
| NamingException savedException = null; |
| |
| for (IiopUrl.Address addr : parsedUrl.getAddresses()) { |
| |
| try { |
| try { |
| String tmpUrl = "corbaloc:iiop:" + addr.host |
| + ":" + addr.port + "/NameService"; |
| if (debug) { |
| System.err.println("Using url: " + tmpUrl); |
| } |
| org.omg.CORBA.Object rootCtx = |
| defOrb.string_to_object(tmpUrl); |
| setOrbAndRootContext(defOrb, rootCtx); |
| return parsedUrl.getStringName(); |
| } catch (Exception e) {} // keep going |
| |
| // Get ORB |
| if (debug) { |
| System.err.println("Getting ORB for " + addr.host |
| + " and port " + addr.port); |
| } |
| |
| // Assign to fields |
| setOrbAndRootContext(defOrb, (String)null); |
| return parsedUrl.getStringName(); |
| |
| } catch (NamingException ne) { |
| savedException = ne; |
| } |
| } |
| if (savedException != null) { |
| throw savedException; |
| } else { |
| throw new ConfigurationException("Problem with URL: " + url); |
| } |
| } catch (MalformedURLException e) { |
| throw new ConfigurationException(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Initializes using "corbaname" URL (INS 99-12-03) |
| */ |
| private String initUsingCorbanameUrl(ORB orb, String url, Hashtable<?,?> env) |
| throws NamingException { |
| |
| if (orb == null) |
| orb = getDefaultOrb(); |
| |
| try { |
| CorbanameUrl parsedUrl = new CorbanameUrl(url); |
| |
| String corbaloc = parsedUrl.getLocation(); |
| String cosName = parsedUrl.getStringName(); |
| |
| setOrbAndRootContext(orb, corbaloc); |
| |
| return parsedUrl.getStringName(); |
| } catch (MalformedURLException e) { |
| throw new ConfigurationException(e.getMessage()); |
| } |
| } |
| |
| private void setOrbAndRootContext(ORB orb, String ncIor) |
| throws NamingException { |
| _orb = orb; |
| try { |
| org.omg.CORBA.Object ncRef; |
| if (ncIor != null) { |
| if (debug) { |
| System.err.println("Passing to string_to_object: " + ncIor); |
| } |
| ncRef = _orb.string_to_object(ncIor); |
| } else { |
| ncRef = _orb.resolve_initial_references("NameService"); |
| } |
| if (debug) { |
| System.err.println("Naming Context Ref: " + ncRef); |
| } |
| _nc = NamingContextHelper.narrow(ncRef); |
| if (_nc == null) { |
| if (ncIor != null) { |
| throw new ConfigurationException( |
| "Cannot convert IOR to a NamingContext: " + ncIor); |
| } else { |
| throw new ConfigurationException( |
| "ORB.resolve_initial_references(\"NameService\") does not return a NamingContext"); |
| } |
| } |
| } catch (org.omg.CORBA.ORBPackage.InvalidName in) { |
| NamingException ne = |
| new ConfigurationException( |
| "COS Name Service not registered with ORB under the name 'NameService'"); |
| ne.setRootCause(in); |
| throw ne; |
| } catch (org.omg.CORBA.COMM_FAILURE e) { |
| NamingException ne = |
| new CommunicationException("Cannot connect to ORB"); |
| ne.setRootCause(e); |
| throw ne; |
| } catch (org.omg.CORBA.BAD_PARAM e) { |
| NamingException ne = new ConfigurationException( |
| "Invalid URL or IOR: " + ncIor); |
| ne.setRootCause(e); |
| throw ne; |
| } catch (org.omg.CORBA.INV_OBJREF e) { |
| NamingException ne = new ConfigurationException( |
| "Invalid object reference: " + ncIor); |
| ne.setRootCause(e); |
| throw ne; |
| } |
| } |
| |
| private void setOrbAndRootContext(ORB orb, org.omg.CORBA.Object ncRef) |
| throws NamingException { |
| _orb = orb; |
| try { |
| _nc = NamingContextHelper.narrow(ncRef); |
| if (_nc == null) { |
| throw new ConfigurationException( |
| "Cannot convert object reference to NamingContext: " + ncRef); |
| } |
| } catch (org.omg.CORBA.COMM_FAILURE e) { |
| NamingException ne = |
| new CommunicationException("Cannot connect to ORB"); |
| ne.setRootCause(e); |
| throw ne; |
| } |
| } |
| |
| private String getStringifiedIor(String url) throws NamingException { |
| if (url.startsWith("IOR:") || url.startsWith("corbaloc:")) { |
| return url; |
| } else { |
| InputStream in = null; |
| try { |
| URL u = new URL(url); |
| in = u.openStream(); |
| if (in != null) { |
| BufferedReader bufin = |
| new BufferedReader(new InputStreamReader(in, "8859_1")); |
| String str; |
| while ((str = bufin.readLine()) != null) { |
| if (str.startsWith("IOR:")) { |
| return str; |
| } |
| } |
| } |
| } catch (IOException e) { |
| NamingException ne = |
| new ConfigurationException("Invalid URL: " + url); |
| ne.setRootCause(e); |
| throw ne; |
| } finally { |
| try { |
| if (in != null) { |
| in.close(); |
| } |
| } catch (IOException e) { |
| NamingException ne = |
| new ConfigurationException("Invalid URL: " + url); |
| ne.setRootCause(e); |
| throw ne; |
| } |
| } |
| throw new ConfigurationException(url + " does not contain an IOR"); |
| } |
| } |
| |
| |
| /** |
| * Does the job of calling the COS Naming API, |
| * resolve, and performs the exception mapping. If the resolved |
| * object is a COS Naming Context (sub-context), then this function |
| * returns a new JNDI naming context object. |
| * @param path the NameComponent[] object. |
| * @exception NotFound No objects under the name. |
| * @exception CannotProceed Unable to obtain a continuation context |
| * @exception InvalidName Name not understood. |
| * @return Resolved object returned by the COS Name Server. |
| */ |
| java.lang.Object callResolve(NameComponent[] path) |
| throws NamingException { |
| try { |
| org.omg.CORBA.Object obj = _nc.resolve(path); |
| try { |
| NamingContext nc = |
| NamingContextHelper.narrow(obj); |
| if (nc != null) { |
| return new CNCtx(_orb, orbTracker, nc, _env, |
| makeFullName(path)); |
| } else { |
| return obj; |
| } |
| } catch (org.omg.CORBA.SystemException e) { |
| return obj; |
| } |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, path); |
| } |
| } |
| |
| /** |
| * Converts the "String" name into a CompositeName |
| * returns the object resolved by the COS Naming api, |
| * resolve. Returns the current context if the name is empty. |
| * Returns either an org.omg.CORBA.Object or javax.naming.Context object. |
| * @param name string used to resolve the object. |
| * @exception NamingException See callResolve. |
| * @return the resolved object |
| */ |
| public java.lang.Object lookup(String name) throws NamingException { |
| if (debug) { |
| System.out.println("Looking up: " + name); |
| } |
| return lookup(new CompositeName(name)); |
| } |
| |
| /** |
| * Converts the "Name" name into a NameComponent[] object and |
| * returns the object resolved by the COS Naming api, |
| * resolve. Returns the current context if the name is empty. |
| * Returns either an org.omg.CORBA.Object or javax.naming.Context object. |
| * @param name JNDI Name used to resolve the object. |
| * @exception NamingException See callResolve. |
| * @return the resolved object |
| */ |
| public java.lang.Object lookup(Name name) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| if (name.size() == 0 ) |
| return this; // %%% should clone() so that env can be changed |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| java.lang.Object answer = null; |
| |
| try { |
| answer = callResolve(path); |
| try { |
| // Check whether object factory codebase is trusted |
| if (CorbaUtils.isObjectFactoryTrusted(answer)) { |
| answer = NamingManager.getObjectInstance( |
| answer, name, this, _env); |
| } |
| } catch (NamingException e) { |
| throw e; |
| } catch (Exception e) { |
| NamingException ne = new NamingException( |
| "problem generating object using object factory"); |
| ne.setRootCause(e); |
| throw ne; |
| } |
| } catch (CannotProceedException cpe) { |
| javax.naming.Context cctx = getContinuationContext(cpe); |
| return cctx.lookup(cpe.getRemainingName()); |
| } |
| return answer; |
| } |
| |
| /** |
| * Performs bind or rebind in the context depending on whether the |
| * flag rebind is set. The only objects allowed to be bound are of |
| * types org.omg.CORBA.Object, org.omg.CosNaming.NamingContext. |
| * You can use a state factory to turn other objects (such as |
| * Remote) into these acceptable forms. |
| * |
| * Uses the COS Naming apis bind/rebind or |
| * bind_context/rebind_context. |
| * @param pth NameComponent[] object |
| * @param obj Object to be bound. |
| * @param rebind perform rebind ? if true performs a rebind. |
| * @exception NotFound No objects under the name. |
| * @exception CannotProceed Unable to obtain a continuation context |
| * @exception AlreadyBound An object is already bound to this name. |
| */ |
| private void callBindOrRebind(NameComponent[] pth, Name name, |
| java.lang.Object obj, boolean rebind) throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| try { |
| // Call state factories to convert |
| obj = NamingManager.getStateToBind(obj, name, this, _env); |
| |
| if (obj instanceof CNCtx) { |
| // Use naming context object reference |
| obj = ((CNCtx)obj)._nc; |
| } |
| |
| if ( obj instanceof org.omg.CosNaming.NamingContext) { |
| NamingContext nobj = |
| NamingContextHelper.narrow((org.omg.CORBA.Object)obj); |
| if (rebind) |
| _nc.rebind_context(pth,nobj); |
| else |
| _nc.bind_context(pth,nobj); |
| |
| } else if (obj instanceof org.omg.CORBA.Object) { |
| if (rebind) |
| _nc.rebind(pth,(org.omg.CORBA.Object)obj); |
| else |
| _nc.bind(pth,(org.omg.CORBA.Object)obj); |
| } |
| else |
| throw new IllegalArgumentException( |
| "Only instances of org.omg.CORBA.Object can be bound"); |
| } catch (BAD_PARAM e) { |
| // probably narrow() failed? |
| NamingException ne = new NotContextException(name.toString()); |
| ne.setRootCause(e); |
| throw ne; |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, pth); |
| } |
| } |
| |
| /** |
| * Converts the "Name" name into a NameComponent[] object and |
| * performs the bind operation. Uses callBindOrRebind. Throws an |
| * invalid name exception if the name is empty. We need a name to |
| * bind the object even when we work within the current context. |
| * @param name JNDI Name object |
| * @param obj Object to be bound. |
| * @exception NamingException See callBindOrRebind |
| */ |
| public void bind(Name name, java.lang.Object obj) |
| throws NamingException { |
| if (name.size() == 0 ) { |
| throw new InvalidNameException("Name is empty"); |
| } |
| |
| if (debug) { |
| System.out.println("Bind: " + name); |
| } |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| |
| try { |
| callBindOrRebind(path, name, obj, false); |
| } catch (CannotProceedException e) { |
| javax.naming.Context cctx = getContinuationContext(e); |
| cctx.bind(e.getRemainingName(), obj); |
| } |
| } |
| |
| static private javax.naming.Context |
| getContinuationContext(CannotProceedException cpe) |
| throws NamingException { |
| try { |
| return NamingManager.getContinuationContext(cpe); |
| } catch (CannotProceedException e) { |
| java.lang.Object resObj = e.getResolvedObj(); |
| if (resObj instanceof Reference) { |
| Reference ref = (Reference)resObj; |
| RefAddr addr = ref.get("nns"); |
| if (addr.getContent() instanceof javax.naming.Context) { |
| NamingException ne = new NameNotFoundException( |
| "No object reference bound for specified name"); |
| ne.setRootCause(cpe.getRootCause()); |
| ne.setRemainingName(cpe.getRemainingName()); |
| throw ne; |
| } |
| } |
| throw e; |
| } |
| } |
| |
| /** |
| * Converts the "String" name into a CompositeName object and |
| * performs the bind operation. Uses callBindOrRebind. Throws an |
| * invalid name exception if the name is empty. |
| * @param name string |
| * @param obj Object to be bound. |
| * @exception NamingException See callBindOrRebind |
| */ |
| public void bind(String name, java.lang.Object obj) throws NamingException { |
| bind(new CompositeName(name), obj); |
| } |
| |
| /** |
| * Converts the "Name" name into a NameComponent[] object and |
| * performs the rebind operation. Uses callBindOrRebind. Throws an |
| * invalid name exception if the name is empty. We must have a name |
| * to rebind the object to even if we are working within the current |
| * context. |
| * @param name string |
| * @param obj Object to be bound. |
| * @exception NamingException See callBindOrRebind |
| */ |
| public void rebind(Name name, java.lang.Object obj) |
| throws NamingException { |
| if (name.size() == 0 ) { |
| throw new InvalidNameException("Name is empty"); |
| } |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| try { |
| callBindOrRebind(path, name, obj, true); |
| } catch (CannotProceedException e) { |
| javax.naming.Context cctx = getContinuationContext(e); |
| cctx.rebind(e.getRemainingName(), obj); |
| } |
| } |
| |
| /** |
| * Converts the "String" name into a CompositeName object and |
| * performs the rebind operation. Uses callBindOrRebind. Throws an |
| * invalid name exception if the name is an empty string. |
| * @param name string |
| * @param obj Object to be bound. |
| * @exception NamingException See callBindOrRebind |
| */ |
| public void rebind(String name, java.lang.Object obj) |
| throws NamingException { |
| rebind(new CompositeName(name), obj); |
| } |
| |
| /** |
| * Calls the unbind api of COS Naming and uses the exception mapper |
| * class to map the exceptions |
| * @param path NameComponent[] object |
| * @exception NotFound No objects under the name. If leaf |
| * is not found, that's OK according to the JNDI spec |
| * @exception CannotProceed Unable to obtain a continuation context |
| * @exception InvalidName Name not understood. |
| */ |
| private void callUnbind(NameComponent[] path) throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| try { |
| _nc.unbind(path); |
| } catch (NotFound e) { |
| // If leaf is the one missing, return success |
| // as per JNDI spec |
| |
| if (leafNotFound(e, path[path.length-1])) { |
| // do nothing |
| } else { |
| throw ExceptionMapper.mapException(e, this, path); |
| } |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, path); |
| } |
| } |
| |
| private boolean leafNotFound(NotFound e, NameComponent leaf) { |
| |
| // This test is not foolproof because some name servers |
| // always just return one component in rest_of_name |
| // so you might not be able to tell whether that is |
| // the leaf (e.g. aa/aa/aa, which one is missing?) |
| |
| NameComponent rest; |
| return e.why.value() == NotFoundReason._missing_node && |
| e.rest_of_name.length == 1 && |
| (rest=e.rest_of_name[0]).id.equals(leaf.id) && |
| (rest.kind == leaf.kind || |
| (rest.kind != null && rest.kind.equals(leaf.kind))); |
| } |
| |
| /** |
| * Converts the "String" name into a CompositeName object and |
| * performs the unbind operation. Uses callUnbind. If the name is |
| * empty, throws an invalid name exception. Do we unbind the |
| * current context (JNDI spec says work with the current context if |
| * the name is empty) ? |
| * @param name string |
| * @exception NamingException See callUnbind |
| */ |
| public void unbind(String name) throws NamingException { |
| unbind(new CompositeName(name)); |
| } |
| |
| /** |
| * Converts the "Name" name into a NameComponent[] object and |
| * performs the unbind operation. Uses callUnbind. Throws an |
| * invalid name exception if the name is empty. |
| * @param name string |
| * @exception NamingException See callUnbind |
| */ |
| public void unbind(Name name) |
| throws NamingException { |
| if (name.size() == 0 ) |
| throw new InvalidNameException("Name is empty"); |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| try { |
| callUnbind(path); |
| } catch (CannotProceedException e) { |
| javax.naming.Context cctx = getContinuationContext(e); |
| cctx.unbind(e.getRemainingName()); |
| } |
| } |
| |
| /** |
| * Renames an object. Since COS Naming does not support a rename |
| * api, this method unbinds the object with the "oldName" and |
| * creates a new binding. |
| * @param oldName string, existing name for the binding. |
| * @param newName string, name used to replace. |
| * @exception NamingException See bind |
| */ |
| public void rename(String oldName,String newName) |
| throws NamingException { |
| rename(new CompositeName(oldName), new CompositeName(newName)); |
| } |
| |
| /** |
| * Renames an object. Since COS Naming does not support a rename |
| * api, this method unbinds the object with the "oldName" and |
| * creates a new binding. |
| * @param oldName JNDI Name, existing name for the binding. |
| * @param newName JNDI Name, name used to replace. |
| * @exception NamingException See bind |
| */ |
| public void rename(Name oldName,Name newName) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| if (oldName.size() == 0 || newName.size() == 0) |
| throw new InvalidNameException("One or both names empty"); |
| java.lang.Object obj = lookup(oldName); |
| bind(newName,obj); |
| unbind(oldName); |
| } |
| |
| /** |
| * Returns a NameClassEnumeration object which has a list of name |
| * class pairs. Lists the current context if the name is empty. |
| * @param name string |
| * @exception NamingException All exceptions thrown by lookup |
| * with a non-null argument |
| * @return a list of name-class objects as a NameClassEnumeration. |
| */ |
| public NamingEnumeration<NameClassPair> list(String name) throws NamingException { |
| return list(new CompositeName(name)); |
| } |
| |
| /** |
| * Returns a NameClassEnumeration object which has a list of name |
| * class pairs. Lists the current context if the name is empty. |
| * @param name JNDI Name |
| * @exception NamingException All exceptions thrown by lookup |
| * @return a list of name-class objects as a NameClassEnumeration. |
| */ |
| @SuppressWarnings("unchecked") |
| public NamingEnumeration<NameClassPair> list(Name name) |
| throws NamingException { |
| return (NamingEnumeration)listBindings(name); |
| } |
| |
| /** |
| * Returns a BindingEnumeration object which has a list of name |
| * object pairs. Lists the current context if the name is empty. |
| * @param name string |
| * @exception NamingException all exceptions returned by lookup |
| * @return a list of bindings as a BindingEnumeration. |
| */ |
| public NamingEnumeration<javax.naming.Binding> listBindings(String name) |
| throws NamingException { |
| return listBindings(new CompositeName(name)); |
| } |
| |
| /** |
| * Returns a BindingEnumeration object which has a list of name |
| * class pairs. Lists the current context if the name is empty. |
| * @param name JNDI Name |
| * @exception NamingException all exceptions returned by lookup. |
| * @return a list of bindings as a BindingEnumeration. |
| */ |
| public NamingEnumeration<javax.naming.Binding> listBindings(Name name) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| if (name.size() > 0) { |
| try { |
| java.lang.Object obj = lookup(name); |
| if (obj instanceof CNCtx) { |
| return new CNBindingEnumeration( |
| (CNCtx) obj, true, _env); |
| } else { |
| throw new NotContextException(name.toString()); |
| } |
| } catch (NamingException ne) { |
| throw ne; |
| } catch (BAD_PARAM e) { |
| NamingException ne = |
| new NotContextException(name.toString()); |
| ne.setRootCause(e); |
| throw ne; |
| } |
| } |
| return new CNBindingEnumeration(this, false, _env); |
| } |
| |
| /** |
| * Calls the destroy on the COS Naming Server |
| * @param nc The NamingContext object to use. |
| * @exception NotEmpty when the context is not empty and cannot be destroyed. |
| */ |
| private void callDestroy(NamingContext nc) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| try { |
| nc.destroy(); |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, null); |
| } |
| } |
| |
| /** |
| * Uses the callDestroy function to destroy the context. If name is |
| * empty destroys the current context. |
| * @param name string |
| * @exception OperationNotSupportedException when list is invoked |
| * with a non-null argument |
| */ |
| public void destroySubcontext(String name) throws NamingException { |
| destroySubcontext(new CompositeName(name)); |
| } |
| |
| /** |
| * Uses the callDestroy function to destroy the context. Destroys |
| * the current context if name is empty. |
| * @param name JNDI Name |
| * @exception OperationNotSupportedException when list is invoked |
| * with a non-null argument |
| */ |
| public void destroySubcontext(Name name) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| NamingContext the_nc = _nc; |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| if ( name.size() > 0) { |
| try { |
| javax.naming.Context ctx = |
| (javax.naming.Context) callResolve(path); |
| CNCtx cnc = (CNCtx)ctx; |
| the_nc = cnc._nc; |
| cnc.close(); //remove the reference to the context |
| } catch (ClassCastException e) { |
| throw new NotContextException(name.toString()); |
| } catch (CannotProceedException e) { |
| javax.naming.Context cctx = getContinuationContext(e); |
| cctx.destroySubcontext(e.getRemainingName()); |
| return; |
| } catch (NameNotFoundException e) { |
| // If leaf is the one missing, return success |
| // as per JNDI spec |
| |
| if (e.getRootCause() instanceof NotFound && |
| leafNotFound((NotFound)e.getRootCause(), |
| path[path.length-1])) { |
| return; // leaf missing OK |
| } |
| throw e; |
| } catch (NamingException e) { |
| throw e; |
| } |
| } |
| callDestroy(the_nc); |
| callUnbind(path); |
| } |
| |
| /** |
| * Calls the bind_new_context COS naming api to create a new subcontext. |
| * @param path NameComponent[] object |
| * @exception NotFound No objects under the name. |
| * @exception CannotProceed Unable to obtain a continuation context |
| * @exception InvalidName Name not understood. |
| * @exception AlreadyBound An object is already bound to this name. |
| * @return the new context object. |
| */ |
| private javax.naming.Context callBindNewContext(NameComponent[] path) |
| throws NamingException { |
| if (_nc == null) |
| throw new ConfigurationException( |
| "Context does not have a corresponding NamingContext"); |
| try { |
| NamingContext nctx = _nc.bind_new_context(path); |
| return new CNCtx(_orb, orbTracker, nctx, _env, |
| makeFullName(path)); |
| } catch (Exception e) { |
| throw ExceptionMapper.mapException(e, this, path); |
| } |
| } |
| |
| /** |
| * Uses the callBindNewContext convenience function to create a new |
| * context. Throws an invalid name exception if the name is empty. |
| * @param name string |
| * @exception NamingException See callBindNewContext |
| * @return the new context object. |
| */ |
| public javax.naming.Context createSubcontext(String name) |
| throws NamingException { |
| return createSubcontext(new CompositeName(name)); |
| } |
| |
| /** |
| * Uses the callBindNewContext convenience function to create a new |
| * context. Throws an invalid name exception if the name is empty. |
| * @param name string |
| * @exception NamingException See callBindNewContext |
| * @return the new context object. |
| */ |
| public javax.naming.Context createSubcontext(Name name) |
| throws NamingException { |
| if (name.size() == 0 ) |
| throw new InvalidNameException("Name is empty"); |
| NameComponent[] path = CNNameParser.nameToCosName(name); |
| try { |
| return callBindNewContext(path); |
| } catch (CannotProceedException e) { |
| javax.naming.Context cctx = getContinuationContext(e); |
| return cctx.createSubcontext(e.getRemainingName()); |
| } |
| } |
| |
| /** |
| * Is mapped to resolve in the COS Naming api. |
| * @param name string |
| * @exception NamingException See lookup. |
| * @return the resolved object. |
| */ |
| public java.lang.Object lookupLink(String name) throws NamingException { |
| return lookupLink(new CompositeName(name)); |
| } |
| |
| /** |
| * Is mapped to resolve in the COS Naming api. |
| * @param name string |
| * @exception NamingException See lookup. |
| * @return the resolved object. |
| */ |
| public java.lang.Object lookupLink(Name name) throws NamingException { |
| return lookup(name); |
| } |
| |
| /** |
| * Allow access to the name parser object. |
| * @param String JNDI name, is ignored since there is only one Name |
| * Parser object. |
| * @exception NamingException -- |
| * @return NameParser object |
| */ |
| public NameParser getNameParser(String name) throws NamingException { |
| return parser; |
| } |
| |
| /** |
| * Allow access to the name parser object. |
| * @param Name JNDI name, is ignored since there is only one Name |
| * Parser object. |
| * @exception NamingException -- |
| * @return NameParser object |
| */ |
| public NameParser getNameParser(Name name) throws NamingException { |
| return parser; |
| } |
| |
| /** |
| * Returns the current environment. |
| * @return Environment. |
| */ |
| @SuppressWarnings("unchecked") |
| public Hashtable<String, java.lang.Object> getEnvironment() throws NamingException { |
| if (_env == null) { |
| return new Hashtable<>(5, 0.75f); |
| } else { |
| return (Hashtable<String, java.lang.Object>)_env.clone(); |
| } |
| } |
| |
| public String composeName(String name, String prefix) throws NamingException { |
| return composeName(new CompositeName(name), |
| new CompositeName(prefix)).toString(); |
| } |
| |
| public Name composeName(Name name, Name prefix) throws NamingException { |
| Name result = (Name)prefix.clone(); |
| return result.addAll(name); |
| } |
| |
| /** |
| * Adds to the environment for the current context. |
| * Record change but do not reinitialize ORB. |
| * |
| * @param propName The property name. |
| * @param propVal The ORB. |
| * @return the previous value of this property if any. |
| */ |
| @SuppressWarnings("unchecked") |
| public java.lang.Object addToEnvironment(String propName, |
| java.lang.Object propValue) |
| throws NamingException { |
| if (_env == null) { |
| _env = new Hashtable<>(7, 0.75f); |
| } else { |
| // copy-on-write |
| _env = (Hashtable<String, java.lang.Object>)_env.clone(); |
| } |
| |
| return _env.put(propName, propValue); |
| } |
| |
| // Record change but do not reinitialize ORB |
| @SuppressWarnings("unchecked") |
| public java.lang.Object removeFromEnvironment(String propName) |
| throws NamingException { |
| if (_env != null && _env.get(propName) != null) { |
| // copy-on-write |
| _env = (Hashtable<String, java.lang.Object>)_env.clone(); |
| return _env.remove(propName); |
| } |
| return null; |
| } |
| |
| synchronized public void incEnumCount() { |
| enumCount++; |
| if (debug) { |
| System.out.println("incEnumCount, new count:" + enumCount); |
| } |
| } |
| |
| synchronized public void decEnumCount() |
| throws NamingException { |
| enumCount--; |
| if (debug) { |
| System.out.println("decEnumCount, new count:" + enumCount + |
| " isCloseCalled:" + isCloseCalled); |
| } |
| if ((enumCount == 0) && isCloseCalled) { |
| close(); |
| } |
| } |
| |
| synchronized public void close() throws NamingException { |
| |
| if (enumCount > 0) { |
| isCloseCalled = true; |
| return; |
| } |
| |
| // Never destroy an orb in CNCtx. |
| // The orb we have is either the shared/default orb, or one passed in to a constructor |
| // from elsewhere, so that orb is somebody else's reponsibility. |
| } |
| |
| protected void finalize() { |
| try { |
| close(); |
| } catch (NamingException e) { |
| // ignore failures |
| } |
| } |
| } |
