/*

 * Copyright (c) 1999, 2011, 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.ldap;

import java.util.Enumeration;

import java.util.Vector;

import java.util.Locale;

import javax.naming.*;

import javax.naming.directory.Attributes;

import javax.naming.directory.Attribute;

import javax.naming.directory.BasicAttributes;

/**

 * <code>LdapName</code> implements compound names for LDAP v3 as

 * specified by RFC 2253.

 *<p>

 * RFC 2253 has a few ambiguities and outright inconsistencies.  These

 * are resolved as follows:

 * <ul>

 * <li> RFC 2253 leaves the term "whitespace" undefined.  The

 *      definition of "optional-space" given in RFC 1779 is used in

 *      its place:  either a space character or a carriage return ("\r").

 * <li> Whitespace is allowed on either side of ',', ';', '=', and '+'.

 *      Such whitespace is accepted but not generated by this code,

 *      and is ignored when comparing names.

 * <li> AttributeValue strings containing '=' or non-leading '#'

 *      characters (unescaped) are accepted.

 * </ul>

 *<p>

 * String names passed to <code>LdapName</code> or returned by it

 * use the full 16-bit Unicode character set.  They may also contain

 * characters encoded into UTF-8 with each octet represented by a

 * three-character substring such as "\\B4".

 * They may not, however, contain characters encoded into UTF-8 with

 * each octet represented by a single character in the string:  the

 * meaning would be ambiguous.

 *<p>

 * <code>LdapName</code> will properly parse all valid names, but

 * does not attempt to detect all possible violations when parsing

 * invalid names.  It's "generous".

 *<p>

 * When names are tested for equality, attribute types and binary

 * values are case-insensitive, and string values are by default

 * case-insensitive.

 * String values with different but equivalent usage of quoting,

 * escaping, or UTF8-hex-encoding are considered equal.  The order of

 * components in multi-valued RDNs (such as "ou=Sales+cn=Bob") is not

 * significant.

 *

 * @author Scott Seligman

 */

public final class LdapName implements Name {

    private transient String unparsed;  // if non-null, the DN in unparsed form

    private transient Vector<Rdn> rdns;      // parsed name components

    private transient boolean valuesCaseSensitive = false;

    /**

     * Constructs an LDAP name from the given DN.

     *

     * @param name      An LDAP DN.  To JNDI, a compound name.

     *

     * @throws InvalidNameException if a syntax violation is detected.

     */

    public LdapName(String name) throws InvalidNameException {

        unparsed = name;

        parse();

    }

    /*

     * Constructs an LDAP name given its parsed components and, optionally

     * (if "name" is not null), the unparsed DN.

     */

    @SuppressWarnings("unchecked") // clone()

    private LdapName(String name, Vector<Rdn> rdns) {

        unparsed = name;

        this.rdns = (Vector<Rdn>)rdns.clone();

    }

    /*

     * Constructs an LDAP name given its parsed components (the elements

     * of "rdns" in the range [beg,end)) and, optionally

     * (if "name" is not null), the unparsed DN.

     */

    private LdapName(String name, Vector<Rdn> rdns, int beg, int end) {

        unparsed = name;

        this.rdns = new Vector<>();

        for (int i = beg; i < end; i++) {

            this.rdns.addElement(rdns.elementAt(i));

        }

    }

    public Object clone() {

        return new LdapName(unparsed, rdns);

    }

    public String toString() {

        if (unparsed != null) {

            return unparsed;

        }

        StringBuffer buf = new StringBuffer();

        for (int i = rdns.size() - 1; i >= 0; i--) {

            if (i < rdns.size() - 1) {

                buf.append(',');

            }

            Rdn rdn = rdns.elementAt(i);

            buf.append(rdn);

        }

        unparsed = new String(buf);

        return unparsed;

    }

    public boolean equals(Object obj) {

        return ((obj instanceof LdapName) &&

                (compareTo(obj) == 0));

    }

    public int compareTo(Object obj) {

        LdapName that = (LdapName)obj;

        if ((obj == this) ||                    // check possible shortcuts

            (unparsed != null && unparsed.equals(that.unparsed))) {

            return 0;

        }

        // Compare RDNs one by one, lexicographically.

        int minSize = Math.min(rdns.size(), that.rdns.size());

        for (int i = 0 ; i < minSize; i++) {

            // Compare a single pair of RDNs.

            Rdn rdn1 = rdns.elementAt(i);

            Rdn rdn2 = that.rdns.elementAt(i);

            int diff = rdn1.compareTo(rdn2);

            if (diff != 0) {

                return diff;

            }

        }

        return (rdns.size() - that.rdns.size());        // longer DN wins

    }

    public int hashCode() {

        // Sum up the hash codes of the components.

        int hash = 0;

        // For each RDN...

        for (int i = 0; i < rdns.size(); i++) {

            Rdn rdn = rdns.elementAt(i);

            hash += rdn.hashCode();

        }

        return hash;

    }

    public int size() {

        return rdns.size();

    }

    public boolean isEmpty() {

        return rdns.isEmpty();

    }

    public Enumeration<String> getAll() {

        final Enumeration<Rdn> enum_ = rdns.elements();

        return new Enumeration<String>() {

            public boolean hasMoreElements() {

                return enum_.hasMoreElements();

            }

            public String nextElement() {

                return enum_.nextElement().toString();

            }

        };

    }

    public String get(int pos) {

        return rdns.elementAt(pos).toString();

    }

    public Name getPrefix(int pos) {

        return new LdapName(null, rdns, 0, pos);

    }

    public Name getSuffix(int pos) {

        return new LdapName(null, rdns, pos, rdns.size());

    }

    public boolean startsWith(Name n) {

        int len1 = rdns.size();

        int len2 = n.size();

        return (len1 >= len2 &&

                matches(0, len2, n));

    }

    public boolean endsWith(Name n) {

        int len1 = rdns.size();

        int len2 = n.size();

        return (len1 >= len2 &&

                matches(len1 - len2, len1, n));

    }

    /**

     * Controls whether string-values are treated as case-sensitive

     * when the string values within names are compared.  The default

     * behavior is case-insensitive comparison.

     */

     public void setValuesCaseSensitive(boolean caseSensitive) {

         toString();

         rdns = null;   // clear any cached information

         try {

             parse();

         } catch (InvalidNameException e) {

             // shouldn't happen

             throw new IllegalStateException("Cannot parse name: " + unparsed);

         }

         valuesCaseSensitive = caseSensitive;

     }

    /*

     * Helper method for startsWith() and endsWith().

     * Returns true if components [beg,end) match the components of "n".

     * If "n" is not an LdapName, each of its components is parsed as

     * the string form of an RDN.

     * The following must hold:  end - beg == n.size().

     */

    private boolean matches(int beg, int end, Name n) {

        for (int i = beg; i < end; i++) {

            Rdn rdn;

            if (n instanceof LdapName) {

                LdapName ln = (LdapName)n;

                rdn = ln.rdns.elementAt(i - beg);

            } else {

                String rdnString = n.get(i - beg);

                try {

                    rdn = (new DnParser(rdnString, valuesCaseSensitive)).getRdn();

                } catch (InvalidNameException e) {

                    return false;

                }

            }

            if (!rdn.equals(rdns.elementAt(i))) {

                return false;

            }

        }

        return true;

    }

    public Name addAll(Name suffix) throws InvalidNameException {

        return addAll(size(), suffix);

    }

    /*

     * If "suffix" is not an LdapName, each of its components is parsed as

     * the string form of an RDN.

     */

    public Name addAll(int pos, Name suffix) throws InvalidNameException {

        if (suffix instanceof LdapName) {

            LdapName s = (LdapName)suffix;

            for (int i = 0; i < s.rdns.size(); i++) {

                rdns.insertElementAt(s.rdns.elementAt(i), pos++);

            }

        } else {

            Enumeration<String> comps = suffix.getAll();

            while (comps.hasMoreElements()) {

                DnParser p = new DnParser(comps.nextElement(),

                    valuesCaseSensitive);

                rdns.insertElementAt(p.getRdn(), pos++);

            }

        }

        unparsed = null;                                // no longer valid

        return this;

    }

    public Name add(String comp) throws InvalidNameException {

        return add(size(), comp);

    }

    public Name add(int pos, String comp) throws InvalidNameException {

        Rdn rdn = (new DnParser(comp, valuesCaseSensitive)).getRdn();

        rdns.insertElementAt(rdn, pos);

        unparsed = null;                                // no longer valid

        return this;

    }

    public Object remove(int pos) throws InvalidNameException {

        String comp = get(pos);

        rdns.removeElementAt(pos);

        unparsed = null;                                // no longer valid

        return comp;

    }

    private void parse() throws InvalidNameException {

        rdns = (new DnParser(unparsed, valuesCaseSensitive)).getDn();

    }

    /*

     * Best guess as to what RFC 2253 means by "whitespace".

     */

    private static boolean isWhitespace(char c) {

        return (c == ' ' || c == '\r');

    }

    /**

     * Given the value of an attribute, returns a string suitable

     * for inclusion in a DN.  If the value is a string, this is

     * accomplished by using backslash (\) to escape the following

     * characters:

     *<ul>

     *<li>leading and trailing whitespace

     *<li><pre>, = + < > # ; " \</pre>

     *</ul>

     * If the value is a byte array, it is converted to hex

     * notation (such as "#CEB1DF80").

     */

    public static String escapeAttributeValue(Object val) {

        return TypeAndValue.escapeValue(val);

    }

    /**

     * Given an attribute value formated according to RFC 2253,

     * returns the unformated value.  Returns a string value as

     * a string, and a binary value as a byte array.

     */

    public static Object unescapeAttributeValue(String val) {

        return TypeAndValue.unescapeValue(val);

    }

    /**

     * Serializes only the unparsed DN, for compactness and to avoid

     * any implementation dependency.

     *

     * @serialdata      The DN string and a boolean indicating whether

     * the values are case sensitive.

     */

    private void writeObject(java.io.ObjectOutputStream s)

            throws java.io.IOException {

        s.writeObject(toString());

        s.writeBoolean(valuesCaseSensitive);

    }

    private void readObject(java.io.ObjectInputStream s)

            throws java.io.IOException, ClassNotFoundException {

        unparsed = (String)s.readObject();

        valuesCaseSensitive = s.readBoolean();

        try {

            parse();

        } catch (InvalidNameException e) {

            // shouldn't happen

            throw new java.io.StreamCorruptedException(

                    "Invalid name: " + unparsed);

        }

    }

    static final long serialVersionUID = -1595520034788997356L;

    /*

     * DnParser implements a recursive descent parser for a single DN.

     */

    static class DnParser {

        private final String name;      // DN being parsed

        private final char[] chars;     // characters in LDAP name being parsed

        private final int len;          // length of "chars"

        private int cur = 0;            // index of first unconsumed char in "chars"

        private boolean valuesCaseSensitive;

        /*

         * Given an LDAP DN in string form, returns a parser for it.

         */

        DnParser(String name, boolean valuesCaseSensitive)

            throws InvalidNameException {

            this.name = name;

            len = name.length();

            chars = name.toCharArray();

            this.valuesCaseSensitive = valuesCaseSensitive;

        }

        /*

         * Parses the DN, returning a Vector of its RDNs.

         */

        Vector<Rdn> getDn() throws InvalidNameException {

            cur = 0;

            Vector<Rdn> rdns = new Vector<>(len / 3 + 10);  // leave room for growth

            if (len == 0) {

                return rdns;

            }

            rdns.addElement(parseRdn());

            while (cur < len) {

                if (chars[cur] == ',' || chars[cur] == ';') {

                    ++cur;

                    rdns.insertElementAt(parseRdn(), 0);

                } else {

                    throw new InvalidNameException("Invalid name: " + name);

                }

            }

            return rdns;

        }

        /*

         * Parses the DN, if it is known to contain a single RDN.

         */

        Rdn getRdn() throws InvalidNameException {

            Rdn rdn = parseRdn();

            if (cur < len) {

                throw new InvalidNameException("Invalid RDN: " + name);

            }

            return rdn;

        }

        /*

         * Parses the next RDN and returns it.  Throws an exception if

         * none is found.  Leading and trailing whitespace is consumed.

         */

        private Rdn parseRdn() throws InvalidNameException {

            Rdn rdn = new Rdn();

            while (cur < len) {

                consumeWhitespace();

                String attrType = parseAttrType();

                consumeWhitespace();

                if (cur >= len || chars[cur] != '=') {

                    throw new InvalidNameException("Invalid name: " + name);

                }

                ++cur;          // consume '='

                consumeWhitespace();

                String value = parseAttrValue();

                consumeWhitespace();

                rdn.add(new TypeAndValue(attrType, value, valuesCaseSensitive));

                if (cur >= len || chars[cur] != '+') {

                    break;

                }

                ++cur;          // consume '+'

            }

            return rdn;

        }

        /*

         * Returns the attribute type that begins at the next unconsumed

         * char.  No leading whitespace is expected.

         * This routine is more generous than RFC 2253.  It accepts

         * attribute types composed of any nonempty combination of Unicode

         * letters, Unicode digits, '.', '-', and internal space characters.

         */

        private String parseAttrType() throws InvalidNameException {

            final int beg = cur;

            while (cur < len) {

                char c = chars[cur];

                if (Character.isLetterOrDigit(c) ||

                      c == '.' ||

                      c == '-' ||

                      c == ' ') {

                    ++cur;

                } else {

                    break;

                }

            }

            // Back out any trailing spaces.

            while ((cur > beg) && (chars[cur - 1] == ' ')) {

                --cur;

            }

            if (beg == cur) {

                throw new InvalidNameException("Invalid name: " + name);

            }

            return new String(chars, beg, cur - beg);

        }

        /*

         * Returns the attribute value that begins at the next unconsumed

         * char.  No leading whitespace is expected.

         */

        private String parseAttrValue() throws InvalidNameException {

            if (cur < len && chars[cur] == '#') {

                return parseBinaryAttrValue();

            } else if (cur < len && chars[cur] == '"') {

                return parseQuotedAttrValue();

            } else {

                return parseStringAttrValue();

            }

        }

        private String parseBinaryAttrValue() throws InvalidNameException {

            final int beg = cur;

            ++cur;                      // consume '#'

            while (cur < len &&

                   Character.isLetterOrDigit(chars[cur])) {

                ++cur;

            }

            return new String(chars, beg, cur - beg);