harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r410240 [1/4] - in /incubator/harmony/enhanced/classlib/trunk/modules/jndi: make/ make/common/ src/main/java/org/apache/harmony/jndi/provider/ src/main/java/org/apache/harmony/jndi/provider/dns/ src/main/java/org/apache/harmony/util/ src/ma...
Date Tue, 30 May 2006 11:25:01 GMT
Author: tellison
Date: Tue May 30 04:24:59 2006
New Revision: 410240

URL: http://svn.apache.org/viewvc?rev=410240&view=rev
Log:
Initial commit of HARMONY-256 (Contribution of DNS service provider for JNDI classlibrary code)


Added:
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContextFactory.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSName.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSNameParser.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSPseudoURL.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DomainProtocolException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/Message.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/ProviderConstants.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/ProviderMgr.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/QuestionRecord.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/Resolver.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/ResolverCache.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/ResourceRecord.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/SList.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/TransportMgr.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/dnsURLContext.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/dnsURLContextFactory.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/util/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/util/logging/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/util/logging/LogConst.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/DNSContextTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/DNSNameParserTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/DNSPseudoURLTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/NSLookup.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/ResourceRecordTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/test/java/org/apache/harmony/jndi/provider/dns/TestMgr.java   (with props)
Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/common/build.xml
    incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/patternset.txt

Modified: incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/common/build.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/common/build.xml?rev=410240&r1=410239&r2=410240&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/common/build.xml (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/common/build.xml Tue May 30 04:24:59 2006
@@ -101,7 +101,8 @@
 
                 <fileset dir="${hy.jndi.src.test.java}">
                     <include name="**/*Test.java"/>
-                	
+                        <exclude name="org/apache/harmony/jndi/provider/dns/DNSContextTest.java" />                	
+
                 	<!--  These tests run in a separate jvm below -->
                 	<exclude name="org/apache/harmony/jndi/tests/javax/naming/spi/NamingManagerBuilderTest.java" />
                     <exclude name="org/apache/harmony/jndi/tests/javax/naming/spi/NamingManagerTest.java" />

Modified: incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/patternset.txt
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/patternset.txt?rev=410240&r1=410239&r2=410240&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/patternset.txt (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/jndi/make/patternset.txt Tue May 30 04:24:59 2006
@@ -18,4 +18,5 @@
 javax/naming/ldap/*
 javax/naming/spi/*
 
-org/apache/harmony/jndi/internal/*
\ No newline at end of file
+org/apache/harmony/jndi/**
+org/apache/harmony/util/logging/LogConst.*

Added: incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java?rev=410240&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java Tue May 30 04:24:59 2006
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2005-2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Alexei Y. Zakharov
+ * @version $Revision: 1.1.2.4 $
+ */
+package org.apache.harmony.jndi.provider.dns;
+
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import java.util.Enumeration;
+
+/**
+ * Trivial implementation of <code>NamingEnumeration</code> interface.
+ * @author Alexei Zakharov
+ * @version $Revision: 1.1.2.4 $
+ */
+public class BasicNamingEnumerator implements NamingEnumeration {
+    
+    private Enumeration enum1 = null;
+    
+    /**
+     * Constructs new enumerator from existing <code>Enumeration</code>.
+     * @param enum1 enumeration 
+     */
+    public BasicNamingEnumerator(Enumeration newEnum) {
+        this.enum1 = newEnum;
+    }
+
+    /**
+     * @return next element of enumeration
+     * @see javax.naming.NamingEnumeration#next()
+     */
+    public Object next() {
+        return enum1.nextElement();
+    }
+
+    /**
+     * @return <code>true</code> if the enumeration has more elements
+     * @see javax.naming.NamingEnumeration#hasMore()
+     */
+    public boolean hasMore() {
+        return enum1.hasMoreElements();
+    }
+
+    /**
+     * Do nothing in current implementation.
+     * @see javax.naming.NamingEnumeration#close()
+     */
+    public void close() throws NamingException {}
+
+    /**
+     * @return next element of enumeration
+     * @see java.util.Enumeration#nextElement()
+     */
+    public Object nextElement() {
+        return enum1.nextElement();
+    }
+
+    /**
+     * @return <code>true</code> if the enumeration has more elements
+     * @see java.util.Enumeration#hasMoreElements()
+     */
+    public boolean hasMoreElements() {
+        return enum1.hasMoreElements();
+    }
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/BasicNamingEnumerator.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java?rev=410240&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java Tue May 30 04:24:59 2006
@@ -0,0 +1,1943 @@
+/*
+ * Copyright 2005-2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Alexei Y. Zakharov
+ * @version $Revision: 1.1.2.5 $
+ */
+package org.apache.harmony.jndi.provider.dns;
+
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.StringTokenizer;
+
+import javax.naming.Binding;
+import javax.naming.CannotProceedException;
+import javax.naming.CompositeName;
+import javax.naming.ConfigurationException;
+import javax.naming.Context;
+import javax.naming.InvalidNameException;
+import javax.naming.Name;
+import javax.naming.NameClassPair;
+import javax.naming.NameParser;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.NoPermissionException;
+import javax.naming.NotContextException;
+import javax.naming.OperationNotSupportedException;
+import javax.naming.RefAddr;
+import javax.naming.Reference;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+import javax.naming.directory.BasicAttribute;
+import javax.naming.directory.BasicAttributes;
+import javax.naming.directory.DirContext;
+import javax.naming.directory.InvalidAttributeIdentifierException;
+import javax.naming.directory.ModificationItem;
+import javax.naming.directory.SearchControls;
+import javax.naming.spi.DirectoryManager;
+import javax.naming.spi.NamingManager;
+
+/**
+ * This class represents DNS context. This is the main class and the main entry
+ * point to DNS service provider for JNDI.
+ *
+ * @author Alexei Zakharov
+ * @version $Revision: 1.1.2.5 $
+ * @see dnsURLContext
+ * @see DNSName
+ * @see DNSNameParser
+ */
+public class DNSContext implements DirContext, Cloneable {
+
+    // some environment property names
+    public static final String LOOKUP_ATTR =
+            "org.apache.harmony.jndi.provider.dns.lookup.attr";
+    public static final String RECURSION =
+            "org.apache.harmony.jndi.provider.dns.recursion";
+    public static final String TIMEOUT_INITIAL =
+            "org.apache.harmony.jndi.provider.dns.timeout.initial";
+    public static final String TIMEOUT_RETRIES =
+            "org.apache.harmony.jndi.provider.dns.timeout.retries";
+    public static final String THREADS_MAX =
+            "org.apache.harmony.jndi.provider.dns.threads.max";
+
+    // used in internal methods
+    private static int NAME_CLASS_SWT = 1;
+    private static int BINDING_SWT = 2;
+    
+    private DNSNameParser nameParser = null;
+    private Hashtable environment = null;
+    private Resolver resolver = null;
+
+    private DNSName contextName = null;
+
+    // default values for properties that has been read from the environment
+    private boolean authoritative = ProviderConstants.DEFAULT_AUTHORITATIVE;
+    private int lookupAttrType = ProviderConstants.DEFAULT_LOOKUP_ATTR_TYPE;
+    private int lookupAttrClass = ProviderConstants.DEFAULT_LOOKUP_ATTR_CLASS;
+    private boolean recursion = ProviderConstants.DEFAULT_RECURSION;
+    private int timeoutInitial = ProviderConstants.DEFAULT_INITIAL_TIMEOUT;
+    private int timeoutRetries = ProviderConstants.DEFAULT_TIMEOUT_RETRIES;
+    private int maxThreads = ProviderConstants.DEFAULT_MAX_THREADS;
+
+    // <--- start of constructor section
+    
+    /**
+     * A DNS context constructor. Should not be accessed directly.
+     * @param env the hash table with environment variables. The context
+     * will make a clone of given hash table.
+     * @throws InvalidNameException something wrong with domain names given in
+     * <code>java.naming.provider.url</code> property
+     * @throws ConfigurationException if some error occured during parsing of
+     * configuration parameters
+     * @throws NamingException if some parse error occured
+     * @throws NullPointerException if the environment is null
+     *  
+     */
+    DNSContext(Hashtable env) throws NamingException
+    {
+        nameParser = new DNSNameParser();
+        if (env == null) {
+           throw new NullPointerException("environment is null");
+        }
+        this.environment = (Hashtable) env.clone();
+        parseBoolProp(Context.AUTHORITATIVE);
+        parseLookupProp();
+        if (environment.containsKey(RECURSION)) {
+            parseBoolProp(RECURSION);
+        }
+        if (environment.containsKey(TIMEOUT_INITIAL)) {
+            parseIntProp(TIMEOUT_INITIAL);
+        }
+        if (environment.containsKey(TIMEOUT_RETRIES)) {
+            parseIntProp(TIMEOUT_RETRIES);
+        }
+        parseIntProp(THREADS_MAX);
+        resolver = new Resolver(timeoutInitial, timeoutRetries, maxThreads,
+                authoritative, recursion);
+        parseProviderUrlProp();
+    }
+
+    /**
+     * Parses integer environment property and fills appropriate internal
+     * variable if necessary.
+     * @param paramName name of parameter
+     * @throws NumberFormatException if error encountered while parsing
+     */
+    private void parseIntProp(String paramName)
+            throws NumberFormatException
+    {
+        Object tmp = environment.get(paramName);
+
+        if (tmp != null && tmp instanceof String) {
+            try {
+                int n = Integer.parseInt((String) tmp);
+
+                if (paramName.equals(TIMEOUT_RETRIES)) {
+                    timeoutRetries = n;
+                } else if (paramName.equals(TIMEOUT_INITIAL)) {
+                    timeoutInitial = n;
+                } else if (paramName.equals(THREADS_MAX)) {
+                    maxThreads = n;
+                } 
+            } catch (NumberFormatException e) {
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * Parses boolean environment property and fills appropriate internal
+     * variable if necessary.
+     * @param paramName name of parameter
+     */
+    private void parseBoolProp(String paramName)
+    {
+        Object tmp = environment.get(paramName);
+        boolean val = false;
+
+        if (tmp != null) {
+            if (tmp instanceof String && tmp.equals("true")) {
+                val = true;
+            }
+            if (paramName.equals(Context.AUTHORITATIVE)) {
+                authoritative = val;
+            } else if (paramName.equals(DNSContext.RECURSION)) {
+                recursion = val;
+            }
+        }
+    }
+
+    /**
+     * Parses "lookup attribute" environment property and fills appropriate
+     * internal variable.
+     * @throws ConfigurationException if some DNS type or DNS class is unknown
+     */
+    private void parseLookupProp() throws ConfigurationException {
+        Object tmp;
+
+        if (environment.containsKey(LOOKUP_ATTR)) {
+            int k;
+            String recClassName;
+            String recTypeName;
+            String lookupAttr;
+
+            tmp = environment.get(LOOKUP_ATTR);
+            if (tmp instanceof String) {
+                lookupAttr = (String) tmp;
+                k = lookupAttr.indexOf(" ");
+                if (k > -1) {
+                    recClassName = lookupAttr.substring(0, k);
+
+                    lookupAttrClass = ProviderMgr.getRecordClassNumber(
+                            recClassName);
+                    if (lookupAttrClass == -1) {
+                        throw new ConfigurationException("DNS class " +
+                                recClassName + " is not supported");
+                    }
+                    recTypeName = lookupAttr.substring(k).trim();
+                }
+                else {
+                    lookupAttrClass =
+                            ProviderConstants.DEFAULT_LOOKUP_ATTR_CLASS;
+                    recTypeName = lookupAttr.trim();
+                }
+                lookupAttrType = ProviderMgr.getRecordTypeNumber(recTypeName);
+                if (lookupAttrType == -1) {
+                    throw new ConfigurationException("DNS type " +
+                            recTypeName + " is not supported");
+                }
+            }
+        }
+    }
+
+    /**
+     * Parses "provider URL" environment property and fills appropriate
+     * internal variable.
+     * @throws NamingException if such exception encountered while parsing
+     */
+    private void parseProviderUrlProp() throws NamingException {
+        Object tmp;
+        
+        if (environment.containsKey(Context.PROVIDER_URL)) {
+            tmp = environment.get(Context.PROVIDER_URL);
+            if (tmp instanceof String) {
+                StringTokenizer st = new StringTokenizer((String) tmp, " ");
+                
+                while (st.hasMoreTokens()) {
+                    String token = st.nextToken();
+                    DNSPseudoURL dnsURL;
+
+                    try {
+                        dnsURL = new DNSPseudoURL(token);
+                        if (dnsURL.isHostIpGiven()) {
+                            resolver.addInitialServer(null, dnsURL.getHost(),
+                                    dnsURL.getPort(), dnsURL.getDomain());
+                        }
+                        else {
+                            resolver.addInitialServer(dnsURL.getHost(), null, 
+                                    dnsURL.getPort(), dnsURL.getDomain());
+                        }
+                        if (contextName == null) {
+                            contextName = (DNSName)
+                                    nameParser.parse(dnsURL.getDomain());
+                        }
+                        else {
+                            DNSName name2 = (DNSName)
+                                    nameParser.parse(dnsURL.getDomain());
+
+                            if (name2.compareTo(contextName) != 0) {
+                                throw new ConfigurationException(
+                                        "conflicting domains: " +
+                                        contextName + " and " +
+                                        name2);
+                            }
+                        }
+                    } catch (IllegalArgumentException e) {
+                        throw new ConfigurationException(
+                                "Unable to parse DNS URL " +
+                                token + ". " + e.getMessage());
+                    }
+                }
+            }
+        } else {
+            contextName = ProviderConstants.ROOT_ZONE_NAME_OBJ;
+        }
+    }
+
+    
+    /**
+     * Constructs new DNS context with given name. This
+     * constructor will read all private properties from its ancestor context.
+     * The environment will not be parsed.
+     * @param ancestorCtx an ancestor context to read all internal properties from
+     * @param name name of newly created context in the ancestor context
+     */
+    DNSContext(DNSContext ancestorCtx, DNSName name) {
+        this.contextName = (DNSName) name.clone();
+        this.nameParser = ancestorCtx.nameParser;
+        this.environment = (Hashtable) ancestorCtx.environment.clone();
+        this.resolver = ancestorCtx.resolver;
+        this.authoritative = ancestorCtx.authoritative;
+        this.lookupAttrType = ancestorCtx.lookupAttrType;
+        this.lookupAttrClass = ancestorCtx.lookupAttrClass;
+        this.recursion = ancestorCtx.recursion;
+        this.timeoutInitial = ancestorCtx.timeoutInitial;
+        this.timeoutRetries = ancestorCtx.timeoutRetries;
+        this.maxThreads = ancestorCtx.maxThreads;
+    }
+    
+    // <----- end of constructor section
+
+    /**
+     * Obtains all attributes associated with given name.
+     * @param name domain name or composite name in string form
+     * @return collection of found attributes
+     * @throws NamingException or its subtype if such has been encountered
+     * @see DNSContext#getAttributes(Name, String[]) for more details 
+     * @see javax.naming.directory.DirContext#getAttributes(java.lang.String)
+     */
+    public Attributes getAttributes(String name) throws NamingException {
+        return getAttributes(convertNameFromStringForm(name), null);
+    }
+
+    /** 
+     * This method is not supported by the DNS provider.
+     * @see javax.naming.directory.DirContext#modifyAttributes(java.lang.String, int, javax.naming.directory.Attributes)
+     */
+    public void modifyAttributes(String arg0, int arg1, Attributes arg2)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            ((DirContext) obj).modifyAttributes("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /**
+     * Determines all attributes associated with given name.
+     * 
+     * @param name the name to look for; should be an instance of either
+     * <code>DNSName</code> class or <code>CompositeName</code> class
+     * @return collection of found attributes
+     * @throws NamingException or its subtype if such has been encountered
+     * @see DNSContext#getAttributes(Name, String[]) for more details 
+     * @see javax.naming.directory.DirContext#getAttributes(javax.naming.Name)
+     */
+    public Attributes getAttributes(Name name) throws NamingException {
+        return getAttributes(name, null);
+    }
+
+    /** 
+     * This method is not supported by the DNS provider.
+     * @see javax.naming.directory.DirContext#modifyAttributes(javax.naming.Name, int, javax.naming.directory.Attributes)
+     */
+    public void modifyAttributes(Name arg0, int arg1, Attributes arg2)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            ((DirContext) obj).modifyAttributes("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported by the DNS provider.
+     * @see javax.naming.directory.DirContext#getSchema(java.lang.String)
+     */
+    public DirContext getSchema(String arg0) throws NamingException {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).getSchema("");
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#getSchemaClassDefinition(java.lang.String)
+     */
+    public DirContext getSchemaClassDefinition(String arg0)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).getSchemaClassDefinition("");
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#getSchema(javax.naming.Name)
+     */
+    public DirContext getSchema(Name arg0) throws NamingException {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).getSchema("");
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#getSchemaClassDefinition(javax.naming.Name)
+     */
+    public DirContext getSchemaClassDefinition(Name arg0)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).getSchemaClassDefinition("");
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#modifyAttributes(java.lang.String, javax.naming.directory.ModificationItem[])
+     */
+    public void modifyAttributes(String arg0, ModificationItem[] arg1)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            ((DirContext) obj).modifyAttributes("", arg1);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#modifyAttributes(javax.naming.Name, javax.naming.directory.ModificationItem[])
+     */
+    public void modifyAttributes(Name arg0, ModificationItem[] arg1)
+            throws NamingException {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            ((DirContext) obj).modifyAttributes("", arg1);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(java.lang.String, javax.naming.directory.Attributes)
+     */
+    public NamingEnumeration search(String arg0, Attributes arg1)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(javax.naming.Name, javax.naming.directory.Attributes)
+     */
+    public NamingEnumeration search(Name arg0, Attributes arg1)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#bind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
+     */
+    public void bind(String arg0, Object arg1, Attributes arg2)
+            throws NamingException
+    {
+        bind(convertNameFromStringForm(arg0), arg1, arg2);
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#rebind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
+     */
+    public void rebind(String arg0, Object arg1, Attributes arg2)
+            throws NamingException
+    {
+        rebind(convertNameFromStringForm(arg0), arg1, arg2);
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#bind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
+     */
+    public void bind(Name arg0, Object arg1, Attributes arg2)
+            throws NamingException
+    {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof DirContext) {
+            ((DirContext) pair.context).bind(pair.name, arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#rebind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
+     */
+    public void rebind(Name arg0, Object arg1, Attributes arg2)
+            throws NamingException
+    {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof DirContext) {
+            ((DirContext) pair.context).rebind(pair.name, arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /**
+     * Retrieves attributes associated with given name.
+     * @param name name to look for; should be either domain name or composite
+     * name in string form
+     * @param attrNames array of attribute names that should be retrieved
+     * @return collection of found attributes
+     * @throws NamingException or its subtypes if such have been encountered 
+     * @see #getAttributes(Name) for details 
+     * @see javax.naming.directory.DirContext#getAttributes(java.lang.String,
+     *  java.lang.String[])
+     */
+    public Attributes getAttributes(String name, String[] attrNames)
+            throws NamingException {
+        return getAttributes(convertNameFromStringForm(name), attrNames);
+    }
+
+    /**
+     * Obtains attributes associated with the given name. Each members of
+     * <code>attrNames</code> array should be the correct name of DNS resource
+     * record type (possibly prefixed with correct DNS resource record class)
+     * as specified in RFC 1035. If class name is given then it should be
+     * separated with space from the type name. If class name is missed then
+     * IN class is used by default.   
+     *  
+     * @param name the name to look for; should have either <code>DNSName</code>
+     * type or <code>CompositeName</code> type 
+     * @param attrNames the array with names of attributes to look for; if
+     *  null then all attributes will be retrieved; if
+     * empty then none of attributes will be retrieved
+     * @throws InvalidNameException if <code>name</code> is neither the instance
+     * of <code>DNSName</code> nor <code>CompositeName</code> class or the first
+     * component of composite name is not a domain name 
+     * @throws InvalidAttributeIdentifierException if the name of DNS type or
+     * DNS class given in <code>attrNames</code> array is invalid
+     * @throws NameNotFoundException if authoritative server for desired
+     * zone was contacted but given name has not been found in that zone
+     * @throws ServiceUnavailableException if no authoritative server for
+     * desired name was found or all servers are dead or malfunction   
+     * @throws NoPermissionException if no appropriate permissions on using
+     * network resources were granted
+     * @throws NullPointerException if <code>name</code> is null
+     * @throws NamingException if some other type of problem has been
+     * encountered
+     * @see javax.naming.directory.DirContext#getAttributes(javax.naming.Name,
+     *  java.lang.String[])
+     * @see RFC 1035
+     */
+    public Attributes getAttributes(Name name, String[] attrNames)
+            throws NamingException
+    {
+        int[] types;
+        int[] classes;
+        DNSName nameToLookFor = null;
+        DNSName altName = null;
+        CompositeName remainingName = null;
+        Attributes attrs = null;
+
+        // analyze given name object
+        if (name == null) {
+            throw new NullPointerException("The name is null");
+        }
+        else if (name.size() == 0) {
+            // attributes of the current context are requested
+            nameToLookFor = (DNSName) contextName.clone();
+        }
+        else if (name instanceof CompositeName) {
+            // treat the first component of the given composite name as
+            // a domain name and the rest as a Next Naming System name
+            String tmp = name.get(0);
+            // check if it is really a domain name
+            altName = (DNSName) nameParser.parse(tmp);
+            //if (!altName.isAbsolute()) {
+            nameToLookFor = (DNSName) composeName(altName, contextName);
+            //} else {
+            //    nameToLookFor = (DNSName) altName.clone();
+            //}
+            if (name.size() > 1) {
+                remainingName = (CompositeName) name.getSuffix(1);
+            }
+        }
+        else if (name instanceof DNSName) {
+            //if (!((DNSName) name).isAbsolute()) {
+            nameToLookFor = (DNSName) composeName(name, contextName);
+            //} else {
+            //    nameToLookFor = (DNSName) name.clone();
+            //}
+        }
+        else {
+            throw new InvalidNameException("Only instances of CompositeName " +
+                    "class or DNSName class are acceptable");
+        }
+
+        // we should have correct nameToLookFor at this point
+        if (remainingName != null) {
+            CannotProceedException cpe = constructCannotProceedException(
+                    altName, remainingName);
+            DirContext nnsContext =
+                    DirectoryManager.getContinuationDirContext(cpe);
+
+            attrs = nnsContext.getAttributes(remainingName, attrNames);
+        } else {
+            DNSContext resolvedCtx = new DNSContext(this, nameToLookFor);
+                
+            // analyze given attrNames object
+            if (attrNames == null) {
+                // this means that all attributes should be obtained
+                types = new int[1];
+                classes = new int[1];
+                types[0] = ProviderConstants.ANY_QTYPE;
+                classes[0] = ProviderConstants.ANY_QCLASS;
+            }
+            else {
+                HashSet classesSet = new HashSet();
+                HashSet typesSet = new HashSet();
+                Iterator iter;
+                int j;
+
+                for (int i = 0; i < attrNames.length; i++) {
+                    int k = attrNames[i].indexOf(' ');
+                    String typeStr = null;
+                    int classInt;
+                    int typesInt;
+    
+                    if (k > 0) {
+                        String classStr = attrNames[i].substring(0, k);
+
+                        classInt =
+                                ProviderMgr.getRecordClassNumber(classStr); 
+                        if (classInt == -1) {
+                            throw new InvalidAttributeIdentifierException(
+                                    "Unknown record class: " + classStr);
+                        }
+                        classesSet.add(new Integer(classInt));
+                        typeStr = attrNames[i].substring(k, attrNames[i].length())
+                                .trim();
+                    } 
+                    else {
+                        classesSet.add(new Integer(
+                                ProviderConstants.IN_CLASS));
+                        typeStr = attrNames[i].trim();
+                    }
+                    typesInt = ProviderMgr.getRecordTypeNumber(typeStr);
+                    if (typesInt == -1) {
+                        throw new InvalidAttributeIdentifierException(
+                                "Unknown record type: " + typeStr);
+                    }
+                    typesSet.add(new Integer(typesInt));
+                }
+                // filling classes array
+                classes = new int[classesSet.size()];
+                iter = classesSet.iterator();
+                j = 0;
+                while (iter.hasNext()) {
+                    Integer n = (Integer) iter.next();
+
+                    classes[j++] = n.intValue();
+                }
+                // filling types array
+                types = new int[typesSet.size()];
+                iter = typesSet.iterator();
+                j = 0;
+                while (iter.hasNext()) {
+                    Integer n = (Integer) iter.next();
+
+                    types[j++] = n.intValue();
+                }
+            }
+            
+            // we should have correct nameToLookFor, classes and types at this point
+            // let's look for attributes
+            try {
+                Enumeration records = resolver.lookup(nameToLookFor.toString(),
+                        types, classes);
+
+                attrs = createAttributesFromRecords(records);
+            } catch (SecurityException e) {
+                NoPermissionException e2 = new NoPermissionException();
+
+                e2.setRootCause(e);
+                throw e2;
+            } catch (NamingException e) {
+                throw e;
+            } catch (Exception e) {
+                NamingException ne = new NamingException();
+
+                ne.setRootCause(e);
+                throw ne;
+            }
+        }
+        return attrs;
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#createSubcontext(java.lang.String, javax.naming.directory.Attributes)
+     */
+    public DirContext createSubcontext(String arg0, Attributes arg1)
+            throws NamingException
+    {
+        return createSubcontext(convertNameFromStringForm(arg0), arg1);
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#createSubcontext(javax.naming.Name, javax.naming.directory.Attributes)
+     */
+    public DirContext createSubcontext(Name arg0, Attributes arg1)
+            throws NamingException
+    {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof DirContext) {
+            return ((DirContext) pair.context).createSubcontext(pair.name, arg1);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(java.lang.String, javax.naming.directory.Attributes, java.lang.String[])
+     */
+    public NamingEnumeration search(String arg0, Attributes arg1, String[] arg2)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(javax.naming.Name, javax.naming.directory.Attributes, java.lang.String[])
+     */
+    public NamingEnumeration search(Name arg0, Attributes arg1, String[] arg2)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(java.lang.String, java.lang.String, javax.naming.directory.SearchControls)
+     */
+    public NamingEnumeration search(String arg0, String arg1,
+            SearchControls arg2) throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(javax.naming.Name, java.lang.String, javax.naming.directory.SearchControls)
+     */
+    public NamingEnumeration search(Name arg0, String arg1, SearchControls arg2)
+            throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(java.lang.String, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
+     */
+    public NamingEnumeration search(String arg0, String arg1, Object[] arg2,
+            SearchControls arg3) throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2, arg3);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.directory.DirContext#search(javax.naming.Name, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
+     */
+    public NamingEnumeration search(Name arg0, String arg1, Object[] arg2,
+            SearchControls arg3) throws NamingException
+    {
+        Object obj = lookup(arg0);
+        
+        if (obj instanceof DNSContext) {
+            throw new OperationNotSupportedException();
+        } else if (obj instanceof DirContext) {
+            return ((DirContext) obj).search("", arg1, arg2, arg3);
+        } else {
+            throw new NotContextException("found object is not a DirContext"); 
+        }
+    }
+
+    /**
+     * Frees all resources obtained by the current context.
+     * @see javax.naming.Context#close()
+     */
+    public void close() throws NamingException {
+        // do nothing right now
+    }
+
+    /**
+     * @return fully qualified DNS name of the current context
+     * @see javax.naming.Context#getNameInNamespace()
+     */
+    public String getNameInNamespace() {
+        return contextName.toString();
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#destroySubcontext(java.lang.String)
+     */
+    public void destroySubcontext(String arg0) throws NamingException {
+        destroySubcontext(convertNameFromStringForm(arg0));
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#unbind(java.lang.String)
+     */
+    public void unbind(String arg0) throws NamingException {
+        unbind(convertNameFromStringForm(arg0));
+    }
+
+    /**
+     * Returns a clone of the environment associated with this context.
+     * @return a hash table with the context's environment
+     * @see javax.naming.Context#getEnvironment()
+     */
+    public Hashtable getEnvironment() throws NamingException {
+        return (Hashtable) environment.clone();
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#destroySubcontext(javax.naming.Name)
+     */
+    public void destroySubcontext(Name arg0) throws NamingException {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof Context) {
+            ((Context) pair.context).destroySubcontext(pair.name);
+        } else {
+            throw new NotContextException("found object is not a Context"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#unbind(javax.naming.Name)
+     */
+    public void unbind(Name arg0) throws NamingException {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof Context) {
+            ((Context) pair.context).unbind(pair.name);
+        } else {
+            throw new NotContextException("found object is not a Context"); 
+        }
+    }
+
+    /**
+     * Performs the lookup operation for given name.
+     * The method will try to construct a composite name from given argument
+     * value. If it is succeed and resulting composite name has the size more than
+     * one then the <code>lookup(Name)</code>  version of <code>lookup</code>
+     *  method will be
+     * called with constructed composite name as an argument. If the size of 
+     * constructed composite name equals to one then the value of given argument
+     * will be treated as a string form of a domain name and an attempt
+     * to create an instance of <code>DNSName</code> class will be made. 
+     * The <code>lookup(Name)</code> will be called after this.
+     *     
+     * @param name the name to look for
+     * @return an object associated with given name
+     * @throws InvalidNameException if given argument is a string
+     *  representation of neither a composite name nor a domain name; or the
+     *  first component of the composite name is not a domain name. 
+     * @throws NamingException if some other type of
+     * <code>NamingException</code> was encountered
+     * @throws NullPointerException if the name is null
+     * @see #lookup(Name)
+     * @see javax.naming.Context#lookup(java.lang.String)
+     */
+    public Object lookup(String name) throws NamingException {
+        return lookup(convertNameFromStringForm(name));
+    }
+
+    /**
+     * @param nameStr string representation of a name
+     * @return an instance of <code>CompositeName</code> or
+     *  <code>DNSName</code> class
+     * @throws InvalidNameException if <code>nameStr</code> is neither a string
+     * representation of <code>CompositeName</code> class nor an instance of
+     * <code>DNSName</code> class.
+     */
+    private Name convertNameFromStringForm(String nameStr)
+            throws InvalidNameException
+    {
+        Name nameObj = null;
+        
+        if (nameStr == null) {
+            throw new NullPointerException("The name is null");
+        }
+        nameObj = new CompositeName(nameStr);
+        if (nameObj.size() == 1) {
+            nameObj = nameParser.parse(nameStr);
+        }
+        else if (nameObj.size() == 0) {
+            nameObj = new DNSName();
+        }
+        return nameObj;
+    }
+    
+    /**
+     * Looks for a object associated with the given name. This methods just
+     * forwards the request to <code>#lookup(String)</code> method and do
+     * nothing more.
+     * @param name name to look for
+     * @return found object
+     * @throws NamingException if encountered
+     * @see #lookup(String) for details
+     * @see javax.naming.Context#lookupLink(javax.naming.Name)
+     */
+
+    public Object lookupLink(String name) throws NamingException {
+        return lookup(name);
+    }
+
+    /**
+     * Removes the property with given name from the contex's environment.
+     * @param name the name of the property to remove
+     * @see javax.naming.Context#removeFromEnvironment(java.lang.String)
+     */
+    public Object removeFromEnvironment(String name) {
+        return environment.remove(name);
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#bind(java.lang.String, java.lang.Object)
+     */
+    public void bind(String arg0, Object arg1) throws NamingException {
+        bind(convertNameFromStringForm(arg0), arg1);
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#rebind(java.lang.String, java.lang.Object)
+     */
+    public void rebind(String arg0, Object arg1) throws NamingException {
+        rebind(convertNameFromStringForm(arg0), arg1);
+    }
+
+    /**
+     * Performs the lookup operation for the given name in the current context.
+     * @param name this method looks for object associated with given name 
+     * @return found object
+     * @throws InvalidNameException if the argument is not a valid type, e.g. 
+     * <code>CompositeName</code> or <code>DNSName</code>;
+     * or the first component of given composite name is not a domain name 
+     * @throws NameNotFoundException if authoritative server for desired
+     * zone was contacted but given name has not been found in that zone
+     * @throws ServiceUnavailableException if no authoritative server for
+     * desired name was found or all servers are dead or malfunction   
+     * @throws NoPermissionException if no appropriate permissions on using
+     * network resources were granted
+     * @throws NullPointerException if <code>name</code> is null
+     * @throws NamingException if some other type of
+     * <code>NamingException</code> was encountered
+     * @see javax.naming.Context#lookup(javax.naming.Name)
+     */
+    public Object lookup(Name name) throws NamingException {
+        int[] types = new int[1];
+        int[] classes = new int[1];
+        DNSName nameToLookFor = null;
+        DNSName altName = null;
+        CompositeName remainingName = null;
+        Object result = null;
+
+        // analyze given name object
+        if (name == null) {
+            throw new NullPointerException("The name is null");
+        }
+        else if (name.size() == 0) {
+            // attributes of the current context are requested
+            nameToLookFor = (DNSName) contextName.clone();
+        }
+        else if (name instanceof CompositeName) {
+            // treat the first component of the given composite name as
+            // a domain name and the rest as a Next Naming System name
+            String tmp = name.get(0);
+            // check if it is really a domain name
+            altName = (DNSName) nameParser.parse(tmp);
+            //if (!altName.isAbsolute()) {
+            nameToLookFor = (DNSName) composeName(altName, contextName);
+            //} else {
+            //    nameToLookFor = (DNSName) altName.clone();
+            //}
+            if (name.size() > 1) {
+                remainingName = (CompositeName) name.getSuffix(1);
+            }
+        }
+        else if (name instanceof DNSName) {
+            //if (!((DNSName) name).isAbsolute()) {
+            nameToLookFor = (DNSName) composeName(name, contextName);
+            //} else {
+            //    nameToLookFor = (DNSName) name.clone();
+            //}
+        }
+        else {
+            throw new InvalidNameException("Only instances of CompositeName " +
+                    "class or DNSName class are acceptable");
+        }
+        // we should have correct nameToLookFor at this point
+        types[0] = lookupAttrType;
+        classes[0] = lookupAttrClass;
+        if (remainingName != null) {
+            CannotProceedException cpe = constructCannotProceedException(
+                    altName, remainingName);
+            Context nnsContext = DirectoryManager.getContinuationContext(cpe);
+
+            result = nnsContext.lookup(remainingName);
+        } else {
+            try {
+                DNSContext resolvedCtx = new DNSContext(this, nameToLookFor);
+                Enumeration records = resolver.lookup(nameToLookFor.toString(),
+                        types, classes);
+                Attributes attrs = createAttributesFromRecords(records);
+
+                result = DirectoryManager.getObjectInstance(
+                        resolvedCtx, name, this, environment, attrs);
+            } catch (SecurityException e) {
+                NoPermissionException e2 =
+                        new NoPermissionException(e.getMessage());
+
+                e2.setRootCause(e);
+                throw e2;
+            } catch (NamingException e) {
+                throw e;
+            } catch (Exception e) {
+                NamingException ne = new NamingException(e.getMessage());
+                
+                ne.setRootCause(e);
+                throw ne;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Constructs <code>CannotProcessException</code> object and fills it
+     * with necessary information. Values of some instance variables of the
+     * current context are used.
+     * 
+     * @param name the portion of name that belongs to DNS namespace
+     * @param remainingName the remainder of the name that belongs to NNS
+     *  namespace
+     * @return newly constructed exception object
+     * @throws NamingException if <code>NamingException</code> was encountered
+     * somewhere
+     */
+    private CannotProceedException constructCannotProceedException(
+            DNSName name, CompositeName remainingName)
+            throws NamingException
+    {
+        DNSName nameToLookFor = (DNSName) composeName(name, contextName);
+        final DNSContext resolvedCtx = new DNSContext(this, nameToLookFor);
+        // namespace border violation, need to ask NNS
+        RefAddr refAddr = new RefAddr("nns") {
+            private static final long serialVersionUID = 8654740210501193418L;
+            
+            DNSContext context = (DNSContext) resolvedCtx.clone();
+            
+            public Object getContent() {
+                return context;
+            }
+        };
+        Reference ref = new Reference(
+                this.getClass().getName(), refAddr);
+        CannotProceedException cpe = null;
+        CompositeName resolvedName = null;
+
+        if (environment.containsKey(NamingManager.CPE)) {
+            cpe = (CannotProceedException)
+                    environment.get(NamingManager.CPE);
+            resolvedName = (CompositeName) cpe.getResolvedName();
+            // remove the last component if it is ""
+            // (the sign of the next naming system)
+            if (resolvedName != null &&
+                    resolvedName.get(resolvedName.size() - 1)
+                            .equals(""))
+            {
+                resolvedName.remove(resolvedName.size() - 1);
+            }
+        }                
+        else {
+            cpe = new CannotProceedException();
+        }
+        cpe.setEnvironment((Hashtable) environment.clone());
+        cpe.setAltName(name);
+        cpe.setAltNameCtx((DNSContext) this.clone());
+        cpe.setRemainingName(remainingName);
+        if (resolvedName == null) {
+            resolvedName = new CompositeName();
+        }
+        resolvedName.add(nameToLookFor.toString());
+        // the sign of the next naming system
+        resolvedName.add("");
+        cpe.setResolvedName(resolvedName);
+        cpe.setResolvedObj(ref);
+        return cpe;
+    }
+    
+    /**
+     * Creates an <code>Attributes</code> object from the given enumeration
+     * of resource records.
+     * @param recs enumeration of resource records received from the resolver
+     * @return corresponding instance of <code>Attributes</code>
+     */
+    private static Attributes createAttributesFromRecords(Enumeration recs) {
+        Attributes attrs = new BasicAttributes(true);
+        
+        while (recs.hasMoreElements()) {
+            ResourceRecord curRec = (ResourceRecord) recs.nextElement();
+            String clssTypeStr = null;
+            Attribute oldAttr = null;
+            
+            if (curRec.getRRClass() == ProviderConstants.IN_CLASS) {
+                clssTypeStr = ProviderConstants.rrTypeNames[curRec.getRRType()];
+            }
+            else {
+                clssTypeStr =
+                        ProviderConstants.rrClassNames[curRec.getRRClass()] +
+                        " " + 
+                        ProviderConstants.rrTypeNames[curRec.getRRType()];
+            }
+            oldAttr = attrs.get(clssTypeStr);
+            if (oldAttr != null) {
+                oldAttr.add(oldAttr.size(), curRec.getRData());
+            } else {
+                BasicAttribute attr = new BasicAttribute(clssTypeStr,
+                        curRec.getRData(), false);
+
+                attrs.put(attr);             
+            }
+        }
+        return attrs;
+    }
+    
+    /**
+     * Looks for a object associated with the given name. This methods just
+     * forwards the request to <code>#lookup(Name)</code> method and do nothing
+     * more.
+     * @param name name to look for
+     * @return found object
+     * @throws NamingException if encountered
+     * @see #lookup(Name) for details
+     * @see javax.naming.Context#lookupLink(javax.naming.Name)
+     */
+    public Object lookupLink(Name name) throws NamingException {
+        return lookup(name);
+    }
+    
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#bind(javax.naming.Name, java.lang.Object)
+     */
+    public void bind(Name arg0, Object arg1) throws NamingException {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof Context) {
+            ((Context) pair.context).bind(pair.name, arg1);
+        } else {
+            throw new NotContextException("found object is not a Context"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#rebind(javax.naming.Name, java.lang.Object)
+     */
+    public void rebind(Name arg0, Object arg1) throws NamingException {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof Context) {
+            ((Context) pair.context).rebind(pair.name, arg1);
+        } else {
+            throw new NotContextException("found object is not a Context"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#rename(java.lang.String, java.lang.String)
+     */
+    public void rename(String arg0, String arg1) throws NamingException {
+        rename(convertNameFromStringForm(arg0),
+               convertNameFromStringForm(arg1));
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#createSubcontext(java.lang.String)
+     */
+    public Context createSubcontext(String arg0) throws NamingException {
+        return createSubcontext(convertNameFromStringForm(arg0));
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#createSubcontext(javax.naming.Name)
+     */
+    public Context createSubcontext(Name arg0) throws NamingException {
+        ContextNamePair pair;
+        
+        try {
+            pair = getTargetNamespaceContextNamePair(arg0);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair.context instanceof Context) {
+            return ((Context) pair.context).createSubcontext(pair.name);
+        } else {
+            throw new NotContextException("found object is not a Context"); 
+        }
+    }
+
+    /** 
+     * This method is not supported.
+     * @see javax.naming.Context#rename(javax.naming.Name, javax.naming.Name)
+     */
+    public void rename(Name arg0, Name arg1) throws NamingException {
+        ContextNamePair pair1;
+        ContextNamePair pair2;
+        
+        try {
+            pair1 = getTargetNamespaceContextNamePair(arg0);
+            pair2 = getTargetNamespaceContextNamePair(arg1);
+        } catch (IllegalArgumentException e) {
+            throw new OperationNotSupportedException();
+        }
+        if (pair1.context instanceof Context &&
+            pair1.context.getClass().getName().equals(
+                    pair2.context.getClass().getName()) &&
+            ((Context) pair1.context).getNameInNamespace().equals(
+                    ((Context) pair2.context).getNameInNamespace()))
+        {
+            ((Context) pair1.context).rename(pair1.name, pair2.name);
+        } else {
+            throw new NotContextException("found object is not a Context or " +
+                    "target contexts are not equal"); 
+        }
+    }
+
+    /**
+     * Returns the name parser for given name.
+     * @param name a name in the string form to return a name parser for
+     * @return the name parser found
+     * @throws NotContextException if found object is not a context 
+     * @throws NamingException if such exception was encountered during lookup 
+     * @see DNSContext#getNameParser(Name) for details 
+     * @see javax.naming.Context#getNameParser(java.lang.String)
+     */
+    public NameParser getNameParser(String name) throws NamingException {
+        Object obj;
+
+        if (name == null) {
+            throw new NullPointerException("name is null");
+        }
+        obj = lookup(name);
+        if (obj instanceof DNSContext) {
+            return nameParser;
+        }
+        else if (obj instanceof Context) {
+            return ((Context) obj).getNameParser("");
+        }
+        throw new NotContextException("Found object is not a context");
+    }
+
+    /**
+     * Tries to look for the context associated with the given name and returns
+     * the appropriate name parser. For <code>DNSContext</code> this method
+     * will return an instance of <code>DNSNameParser</code> class.
+     * @param a name to return a name parser for
+     * @return a name parser for the naming system the found context is
+     * associated with 
+     * @throws NotContextException if found object is not a context so we
+     * cannot obtain a name parser from it
+     * @throws NamingException if such exception was encountered during lookup
+     * @see javax.naming.Context#getNameParser(javax.naming.Name)
+     */
+    public NameParser getNameParser(Name name) throws NamingException {
+        Object obj;
+
+        if (name == null) {
+            throw new NullPointerException("name is null");
+        }
+        obj = lookup(name);
+        if (obj instanceof DNSContext) {
+            return nameParser;
+        }
+        else if (obj instanceof Context) {
+            return ((Context) obj).getNameParser("");
+        }
+        throw new NotContextException("Found object is not a context");
+    }
+
+    /**
+     * Lists all names along with corresponding class names contained by given
+     * context.
+     * @param name context name to list
+     * @return enumeration of <code>NameClassPair</code> objects 
+     * @throws NamingException if an error was encountered
+     * @see javax.naming.Context#list(javax.naming.Name)
+     */
+    public NamingEnumeration list(String name) throws NamingException {
+        return list_common(convertNameFromStringForm(name), NAME_CLASS_SWT);
+    }
+
+    /**
+     * Lists all names along with corresponding objects contained by given
+     * context.
+     * @param name context name to list
+     * @return enumeration of <code>Binding</code> objects 
+     * @throws NamingException if an error was encountered
+     * @see javax.naming.Context#listBindings(java.lang.String)
+     */
+    public NamingEnumeration listBindings(String name) throws NamingException {
+        return list_common(convertNameFromStringForm(name), BINDING_SWT);
+    }
+
+    /**
+     * Lists all names along with corresponding class names contained by given
+     * context.
+     * @param name context name to list
+     * @return enumeration of <code>NameClassPair</code> objects 
+     * @throws NoPermissionException if the resolver is not allowed to use a
+     *  network subsystem
+     * @throws NameNotFoundException if authoritative server(s) was not found
+     * @throws ServiceUnavailableException if none of found servers permits zone
+     * transfers   
+     * @throws DomainProtocolException if some DNS specific error has occured
+     * @throws NamingException if other type of error has occured 
+     * @see javax.naming.Context#list(javax.naming.Name)
+     */
+    public NamingEnumeration list(Name name) throws NamingException {
+        return list_common(name, NAME_CLASS_SWT);
+    }
+
+    
+    /**
+     * Lists all names along with corresponding class names contained by given
+     * context.
+     * @param name context name to list
+     * @param contentSwt method will return enumeration of
+     *  <code>NameClassPair</code> objects if this switch is set to
+     *  <code>1<code>; enumeration of <code>Binding</code> if the switch is set
+     * to <code>2</code>
+     * @return enumeration of <code>NameClassPair</code> or
+     *  <code>Binding</code> objects 
+     * @throws NamingException
+     * 
+     * TODO better resolve situation then the zone just has been transferred and
+     * then ANY_QTYPE request is performed; we could take the result from
+     * resolver's cache since we are sure the cache is up to date and contains
+     * absolutely all records from target zone
+     */
+    private NamingEnumeration list_common(Name name, int contentSwt)
+            throws NamingException
+    {
+        DNSName nameToList = null;
+        DNSName altName = null;
+        CompositeName remainingName = null;
+        NamingEnumeration result = null;
+
+        if (contentSwt != 1 && contentSwt != 2) {
+            throw new IllegalArgumentException(
+                    "contentSwt should be equal to 1 or 2");
+        }
+        if (name == null) {
+            throw new NullPointerException("name is null");
+        }
+        // analyze given name object
+        else if (name.size() == 0) {
+            // attributes of the current context are requested
+            nameToList = (DNSName) contextName.clone();
+        }
+        else if (name instanceof CompositeName) {
+            // treat the first component of the given composite name as
+            // a domain name and the rest as a Next Naming System name
+            String tmp = name.get(0);
+            // check if it is really a domain name
+            altName = (DNSName) nameParser.parse(tmp);
+            //if (!altName.isAbsolute()) {
+            nameToList = (DNSName) composeName(altName, contextName);
+            //} else {
+            //    nameToList = (DNSName) altName.clone();
+            //}
+            if (name.size() > 1) {
+                remainingName = (CompositeName) name.getSuffix(1);
+            }
+        }
+        else if (name instanceof DNSName) {
+            //if (!((DNSName) name).isAbsolute()) {
+            nameToList = (DNSName) composeName(name, contextName);
+            //} else {
+            //    nameToList = (DNSName) name.clone();
+            //}
+        }
+        else {
+            throw new InvalidNameException("Only instances of CompositeName " +
+                    "class or DNSName class are acceptable");
+        }
+        // we should have correct nameToLookFor at this point
+        if (remainingName != null) {
+            CannotProceedException cpe = constructCannotProceedException(
+                    altName, remainingName);
+            Context nnsContext = DirectoryManager.getContinuationContext(cpe);
+
+            result = nnsContext.list(remainingName);
+        } else {
+            // do the job
+            try {
+                Enumeration resEnum = resolver.list(nameToList.toString());
+                Hashtable entries = new Hashtable();
+                DNSContext targetCtx = new DNSContext(this, nameToList); 
+                
+                // collecting direct children
+                while (resEnum.hasMoreElements()) {
+                    ResourceRecord rr = (ResourceRecord) resEnum.nextElement();
+                    // fullName is an full name of current record
+                    Name curName = nameParser.parse(rr.getName());
+
+                    // if contains direct child of current context
+                    if (curName.startsWith(nameToList) &&
+                            curName.size() > nameToList.size())
+                    {
+                        // extract relative name of direct child 
+                        String elNameStr = curName.get(nameToList.size());
+
+                        // if we don't have such child yet 
+                        if (!entries.containsKey(elNameStr)) {
+                            Object elObj;
+                            Object objToPut = null;
+                            // absolute name of direct child
+                            DNSName elNameAbs = null;
+                            // relative name of direct child
+                            DNSName elNameRel = null;
+                            // context that represents direct child
+                            DNSContext elCtx;
+
+                            elNameRel = new DNSName();
+                            elNameRel.add(elNameStr);
+                            elNameAbs = (DNSName) nameToList.clone();
+                            elNameAbs.add(elNameStr);
+                            elCtx = new DNSContext(this, (DNSName) elNameAbs);
+                            elObj = DirectoryManager.getObjectInstance(elCtx,
+                                    elNameRel, targetCtx, environment, null);
+                            switch (contentSwt) {
+                            case 1:
+                                // NameClassPair
+                                objToPut = new NameClassPair(elNameStr,
+                                        elObj.getClass().getName(), true);
+                                break;
+                            case 2:
+                                // Binding
+                                objToPut = new Binding(elNameStr, elObj, true);
+                                break;
+                            }
+                            entries.put(elNameStr, objToPut);
+                        }
+                    }
+                }
+                result = new BasicNamingEnumerator(entries.elements());
+            } catch (SecurityException e) {
+                throw e;
+            } catch (NamingException e) {
+                throw e;
+            } catch (Exception e) {
+                NamingException e2 = new NamingException(e.getMessage());
+                
+                e2.setRootCause(e);
+                throw e2;
+            }
+            
+        }
+        return result;
+    }
+
+    /**
+     * Lists all names along with corresponding objects contained by given
+     * context.
+     * @param name context name to list
+     * @return enumeration of <code>Binding</code> objects 
+     * @throws NamingException if an error was encountered
+     * @see javax.naming.Context#listBindings(javax.naming.Name)
+     */
+    public NamingEnumeration listBindings(Name name) throws NamingException {
+        return list_common(name, BINDING_SWT);
+    }
+
+    /**
+     * Add a new property to the environment.
+     * @param propName a name for the new property
+     * @param propValue a value of the new property
+     * @return an old value of this property; <code>null</code> if not found
+     * @throws NullPointerException if <code>propName</code> or
+     * <code>propValue</code> is null.
+     * @throws NamingException if such was encountered
+     * @see javax.naming.Context#addToEnvironment(java.lang.String, java.lang.Object)
+     */
+    public Object addToEnvironment(String propName, Object propValue)
+         throws NamingException
+    {
+        Object oldVal = environment.put(propName, propValue);
+
+        if (propName.equals(Context.AUTHORITATIVE)) {
+            parseBoolProp(Context.AUTHORITATIVE);
+            resolver.setAuthoritativeAnswerDesired(authoritative);
+        } else if (propName.equals(RECURSION)) {
+            parseBoolProp(RECURSION);
+            resolver.setRecursionDesired(recursion);
+        } else if (propName.equals(TIMEOUT_INITIAL)) {
+            parseIntProp(TIMEOUT_INITIAL);
+            resolver.setInitialTimeout(timeoutInitial);
+        } else if (propName.equals(TIMEOUT_RETRIES)) {
+            parseIntProp(TIMEOUT_RETRIES);
+            resolver.setTimeoutRetries(timeoutRetries);
+        } else if (propName.equals(THREADS_MAX)) {
+            parseIntProp(THREADS_MAX);
+            resolver.setThreadNumberLimit(maxThreads);
+        } else if (propName.equals(LOOKUP_ATTR)) {
+            parseLookupProp();
+        } else if (propName.equals(Context.PROVIDER_URL)) {
+            parseProviderUrlProp();
+        }
+        return oldVal;
+    }
+
+    /**
+     * Appends one name to another. The method initially tries to construct
+     * composite names from given strings. If it succeeds and resulting composite
+     * names have length more than 1 then the method
+     *  <code>composeName(Name, Name)</code> will be called
+     * with constructed composite names as arguments. If one of constructed
+     * composite names (or both) have the length less or equal to 1 then
+     * it will be treated as a string representation of DNS name. The
+     * <code>DNSNameParser.parse</code> method will be called with given string
+     * as an argument. If no exception is thrown then the
+     *  <code>composeName(Name, Name)</code> will be called with the parsed
+     * <code>DNSName</code> as an argument.
+     * @param name a name relative to the current context 
+     * @param prefix the name of the current context in one of its ancestors
+     * @return a composition of <code>prefix</code> and <code>name</code>
+     * @throws NamingException 
+     * @throws NullPointerException if the value of any argument is null 
+     * @see DNSContext#composeName(Name, Name)
+     * @see javax.naming.Context#composeName(java.lang.String, java.lang.String)
+     */
+    public String composeName(String name, String prefix)
+            throws NamingException
+    {
+        Name name1 = null;
+        Name name2 = null;
+        
+        if (name == null || prefix == null) {
+            throw new NullPointerException("Given name of prefix is null");
+        }
+        if (name.length() == 0) {
+            return prefix;
+        }
+        if (prefix.length() == 0) {
+            return name;
+        }
+        try {
+            name1 = new CompositeName(name);
+            name2 = new CompositeName(prefix);
+        }
+        catch (InvalidNameException e) {}
+        if (name1 == null || name1.size() <= 1) {
+            name1 = nameParser.parse(name);
+        }
+        if (name2 == null || name2.size() <= 1) {
+            name2 = nameParser.parse(prefix);
+        }
+        return composeName(name1, name2).toString();
+    }
+
+    /**
+     * Adds <code>name</code> to the end of <code>prefix</code>.
+     * Following cases are checked:
+     * <ol>
+     * <li><code>suffix</code> is a composite name, <code>name</code> is
+     *  compound one</li>
+     * <li><code>suffix</code> is a compound name, <code>name</code> is
+     *  composite one</li>
+     * <li>Both <code>suffix</code> and <code>name</code> are compound names</li>
+     * <li>Both <code>suffix</code> and <code>name</code> are composite names</li>
+     * </ol>
+     * If one of names is a composite name then the result will be also a
+     * composite name. If we are composing compound name and composite name then
+     * the compound name will be converted to the string form and appended
+     * as a member to the resulting composite name.  
+     * @param name a name relative to the current context 
+     * @param prefix the name of the current context in one of its ancestors
+     * @return a composition of <code>prefix</code> and <code>name</code>
+     * @throws NamingException if the compound name is not an instance of
+     * <code>DNSName</code> class or we are trying to append an absolute DNS
+     * name to the non-root prefix.
+     * @throws NullPointerException if <code>name</code> or <code>prefix</code>
+     * is null 
+     * @see javax.naming.Context#composeName(javax.naming.Name, javax.naming.Name)
+     */
+    public Name composeName(Name name, Name prefix) throws NamingException {
+        Name result = null;
+
+        if (name == null || prefix == null) {
+            throw new NullPointerException("The name or prefix given is null");
+        }
+        if (name.size() == 0) {
+            return prefix;
+        }
+        if (prefix.size() == 0) {
+            return name;
+        }
+        if (name instanceof CompositeName && prefix instanceof CompositeName) {
+            // probably we need to glue together the last element of the prefix 
+            // and the first element of the name
+            String comp1 = name.get(0);
+            String comp2 = prefix.get(prefix.size() - 1);
+
+            result = new CompositeName();
+            if (prefix.size() > 1) {
+                result.addAll(prefix.getPrefix(prefix.size() - 1));
+            }
+            try {
+                result.add(concatenateDNSNames(comp1, comp2));
+            } catch (InvalidNameException e) {
+                // comp1 or comp2 is not a valid DNS name
+                // components should be strongly separated
+                result.add(comp2);
+                result.add(comp1);
+            }
+            if (name.size() > 1) {
+                result.addAll(name.getSuffix(1));
+            }
+        }
+        else if (prefix instanceof CompositeName && name instanceof DNSName) {
+            // probably we need to glue together the last element of the prefix 
+            // and the name
+            String comp1 = name.toString();
+            String comp2 = prefix.get(prefix.size() - 1);
+
+            result = new CompositeName();
+            if (prefix.size() > 1) {
+                result.addAll(prefix.getPrefix(prefix.size() - 1));
+            }
+            try {
+                result.add(concatenateDNSNames(comp1, comp2));
+            } catch (InvalidNameException e) {
+                // comp2 is not a valid DNS name
+                // components should be strongly separated
+                result.add(comp2);
+                result.add(comp1);
+            }
+        }
+        else if (prefix instanceof DNSName && name instanceof CompositeName) {
+            // probably we need to glue together the prefix and
+            // the first element of the name
+            String comp1 = name.get(0);
+            String comp2 = prefix.toString();
+
+            result = new CompositeName();
+            try {
+                result.add(concatenateDNSNames(comp1, comp2));
+            } catch (InvalidNameException e) {
+                // comp2 is not a valid DNS name
+                // components should be strongly separated
+                result.add(comp2);
+                result.add(comp1);
+            }
+            if (name.size() > 1) {
+                result.addAll(name.getSuffix(1));
+            }
+        }
+        else if (prefix instanceof DNSName && name instanceof DNSName) {
+            DNSName rootZone = ProviderConstants.ROOT_ZONE_NAME_OBJ;
+            boolean prefixIsRoot = (prefix.compareTo(rootZone) == 0); 
+            boolean nameIsRoot = (name.compareTo(rootZone) == 0);
+            boolean nameStartsFromRoot =
+                name.get(0).equals(""); 
+
+            if (nameStartsFromRoot) {
+                throw new NamingException("Can't append an absolute " +
+                        "DNS name");
+            }
+            if (prefixIsRoot && nameIsRoot) {
+                result = (DNSName) rootZone.clone();
+            }
+            else if (!prefixIsRoot && nameIsRoot) {
+                throw new NamingException("Root domain should " +
+                        "be the rightmost one");
+            }
+            else {
+                result = new DNSName();
+                result.addAll(prefix);
+                result.addAll(name);
+            }
+        }
+        else {
+            throw new NamingException("Only instances of DNSName class " +
+                    "or CompositeName class are acceptable");
+        }
+        return result;
+    }
+
+    /**
+     * Concatenate two DNS name components into one DNS name
+     * @param comp1
+     * @param comp2
+     * @return concatenation of <code>comp1</code> and <code>comp2</code>
+     * @throws InvalidNameException if either <code>comp1</code> or
+     * <code>comp2</code> cannot be parsed
+     * @throws NamingException if DNS name syntax is violated during
+     *  composition of a new name from given components    
+     */
+    private String concatenateDNSNames(String comp1, String comp2)
+            throws NamingException
+    {
+        boolean comp1IsRoot = comp1.equals(".");
+        boolean comp2IsRoot = comp2.equals(".");
+        String composition = null;
+
+        nameParser.parse(comp1);
+        nameParser.parse(comp2);
+        if (comp1.endsWith(".")) {
+            throw new NamingException("Can't append an absolute DNS name");
+        }
+        if (comp1IsRoot && comp2IsRoot) {
+            composition = ".";
+        }
+        else if (!comp1IsRoot && comp2IsRoot) {
+            composition = comp1 + ".";
+        }
+        else if (comp1IsRoot && !comp2IsRoot) {
+            throw new NamingException("Root domain should " +
+                    "be the rightmost one");
+        }
+        else {
+            composition = comp1 + "."  + comp2;
+        }
+        return composition;
+    }
+
+    /**
+     * Constructs the clone of this DNS context.
+     * @see Object#clone()
+     */
+    public Object clone() {
+        return new DNSContext(this, contextName);
+    }
+    
+    /**
+     * Checks if the given object is equal to the current context. It will
+     * return <code>true</code> if and only if the specified object is an 
+     * instance of <code>DNSContext</code> class and has the same domain name.
+     * @param obj an object to compare with
+     * @return <code>true</code> if given object is equal to this one;
+     *  <code>false</code> otherwise
+     */
+    public boolean equals(Object obj) {
+        if (obj != null && obj instanceof DNSContext &&
+                contextName.equals(((DNSContext) obj).contextName)) {
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * @param name composite name to process 
+     * @return root context of the namespace to that the target object belongs
+     *   and the name relative to this root context 
+     */
+    private ContextNamePair getTargetNamespaceContextNamePair(Name cmpName)
+            throws NamingException
+    {
+        CompositeName nameToLookFor;
+        String remainingName;
+        Object obj;
+        
+        if (cmpName == null || !(cmpName instanceof CompositeName) ||
+                cmpName.size() < 2)
+        {
+            throw new IllegalArgumentException();
+        }
+        remainingName = cmpName.get(cmpName.size() - 1);
+        nameToLookFor = (CompositeName) cmpName.getPrefix(cmpName.size() - 1);
+        nameToLookFor.add("");
+        obj = lookup(nameToLookFor);
+        return new ContextNamePair(obj, remainingName);
+    }
+    
+    static class ContextNamePair {
+        ContextNamePair(Object context, String name) {
+            this.context = context;
+            this.name = name;
+        }
+        
+        Object context;
+        String name;
+    }
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/jndi/src/main/java/org/apache/harmony/jndi/provider/dns/DNSContext.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message