/*

 * Copyright 1996-2006 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.security.util;

import java.io.*;

/**

 * Represent an ISO Object Identifier.

 *

 * <P>Object Identifiers are arbitrary length hierarchical identifiers.

 * The individual components are numbers, and they define paths from the

 * root of an ISO-managed identifier space.  You will sometimes see a

 * string name used instead of (or in addition to) the numerical id.

 * These are synonyms for the numerical IDs, but are not widely used

 * since most sites do not know all the requisite strings, while all

 * sites can parse the numeric forms.

 *

 * <P>So for example, JavaSoft has the sole authority to assign the

 * meaning to identifiers below the 1.3.6.1.4.1.42.2.17 node in the

 * hierarchy, and other organizations can easily acquire the ability

 * to assign such unique identifiers.

 *

 *

 * @author David Brownell

 * @author Amit Kapoor

 * @author Hemma Prafullchandra

 */

final public

class ObjectIdentifier implements Serializable

{

    /** use serialVersionUID from JDK 1.1. for interoperability */

    private static final long serialVersionUID = 8697030238860181294L;

    private static final int maxFirstComponent = 2;

    private static final int maxSecondComponent = 39;

    /**

     * Constructs an object identifier from a string.  This string

     * should be of the form 1.23.34.45.56 etc.

     */

    public ObjectIdentifier (String oid) throws IOException

    {

        int ch = '.';

        int     start = 0;

        int end = 0;

        // Calculate length of oid

        componentLen = 0;

        while ((end = oid.indexOf(ch,start)) != -1) {

            start = end + 1;

            componentLen += 1;

        }

        componentLen += 1;

        components = new int[componentLen];

        start = 0;

        int i = 0;

        String comp = null;

        try {

            while ((end = oid.indexOf(ch,start)) != -1) {

                comp = oid.substring(start,end);

                components[i++] = Integer.valueOf(comp).intValue();

                start = end + 1;

            }

            comp = oid.substring(start);

            components[i] = Integer.valueOf(comp).intValue();

        } catch (Exception e) {

            throw new IOException("ObjectIdentifier() -- Invalid format: "

                    + e.toString(), e);

        }

        checkValidOid(components, componentLen);

        this.stringForm = oid;

    }

    /**

     * Check if the values make a legal OID. There must be at least 2

     * components and they must be all non-negative. The first component

     * should be 0,1 or 2. When the first component is 0 or 1, the

     * second component should be less than or equal to 39

     *

     * @param values the components that will make the OID

     * @param len the number of components to check. Note that the allocation

     *        size of <code>values</code> may be longer than <code>len</code>.

     *        In this case, only the first <code>len</code> items are checked.

     * @exception IOException if this is not a legal OID

     */

    private void checkValidOid(int[] values, int len) throws IOException {

        if (values == null || len < 2) {

            throw new IOException("ObjectIdentifier() -- " +

                    "Must be at least two oid components ");

        }

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

            if (values[i] < 0) {

                throw new IOException("ObjectIdentifier() -- " +

                        "oid component #" + (i+1) + " must be non-negative ");

            }

        }

        if (values[0] > maxFirstComponent) {

            throw new IOException("ObjectIdentifier() -- " +

                    "First oid component is invalid ");

        }

        if (values[0] < 2 && values[1] > maxSecondComponent) {

            throw new IOException("ObjectIdentifier() -- " +

                    "Second oid component is invalid ");

        }

    }

    /**

     * Constructs an object ID from an array of integers.  This

     * is used to construct constant object IDs.

     */

    public ObjectIdentifier (int values []) throws IOException

    {

        checkValidOid(values, values.length);

        components = values.clone();

        componentLen = values.length;

    }

    /**

     * Constructs an object ID from an ASN.1 encoded input stream.

     * The encoding of the ID in the stream uses "DER", a BER/1 subset.

     * In this case, that means a triple { typeId, length, data }.

     *

     * <P><STRONG>NOTE:</STRONG>  When an exception is thrown, the

     * input stream has not been returned to its "initial" state.

     *

     * @param in DER-encoded data holding an object ID

     * @exception IOException indicates a decoding error

     */

    public ObjectIdentifier (DerInputStream in)

        throws IOException

    {

        byte    type_id;

        int     bufferEnd;

        /*

         * Object IDs are a "universal" type, and their tag needs only

         * one byte of encoding.  Verify that the tag of this datum

         * is that of an object ID.

         *

         * Then get and check the length of the ID's encoding.  We set

         * up so that we can use in.available() to check for the end of

         * this value in the data stream.

         */

        type_id = (byte) in.getByte ();

        if (type_id != DerValue.tag_ObjectId)

            throw new IOException (

                "ObjectIdentifier() -- data isn't an object ID"

                + " (tag = " +  type_id + ")"

                );

        bufferEnd = in.available () - in.getLength () - 1;

        if (bufferEnd < 0)

            throw new IOException (

                "ObjectIdentifier() -- not enough data");

        initFromEncoding (in, bufferEnd);

    }

    /*

     * Build the OID from the rest of a DER input buffer; the tag

     * and length have been removed/verified

     */

    ObjectIdentifier (DerInputBuffer buf) throws IOException

    {

        initFromEncoding (new DerInputStream (buf), 0);

    }

    /**

     * Private constructor for use by newInternal(). Dummy argument

     * to avoid clash with the public constructor.

     */

    private ObjectIdentifier(int[] components, boolean dummy) {

        this.components = components;

        this.componentLen = components.length;

    }

    /**

     * Create a new ObjectIdentifier for internal use. The values are

     * neither checked nor cloned.

     */

    public static ObjectIdentifier newInternal(int[] values) {

        return new ObjectIdentifier(values, true);

    }

    /*

     * Helper function -- get the OID from a stream, after tag and

     * length are verified.

     */

    private void initFromEncoding (DerInputStream in, int bufferEnd)

        throws IOException

    {

        /*

         * Now get the components ("sub IDs") one at a time.  We fill a

         * temporary buffer, resizing it as needed.

         */

        int             component;

        boolean         first_subid = true;

        for (components = new int [allocationQuantum], componentLen = 0;

                in.available () > bufferEnd;

        ) {

            component = getComponent (in);

            if (component < 0) {

                throw new IOException(

                    "ObjectIdentifier() -- " +

                    "component values must be nonnegative");

            }

            if (first_subid) {

                int     X, Y;

                /*

                 * NOTE:  the allocation quantum is large enough that we know

                 * we don't have to reallocate here!

                 */

                if (component < 40)

                    X = 0;

                else if (component < 80)

                    X = 1;

                else

                    X = 2;

                Y = component - ( X * 40);

                components [0] = X;

                components [1] = Y;

                componentLen = 2;

                first_subid = false;

            } else {

                /*

                 * Other components are encoded less exotically.  The only

                 * potential trouble is the need to grow the array.

                 */

                if (componentLen >= components.length) {

                    int         tmp_components [];

                    tmp_components = new int [components.length

                                        + allocationQuantum];

                    System.arraycopy (components, 0, tmp_components, 0,

                            components.length);

                    components = tmp_components;

                }

                components [componentLen++] = component;

            }

        }

        checkValidOid(components, componentLen);

        /*

         * Final sanity check -- if we didn't use exactly the number of bytes

         * specified, something's quite wrong.

         */

        if (in.available () != bufferEnd) {

            throw new IOException (

                    "ObjectIdentifier() -- malformed input data");

        }

    }

    /*

     * n.b. the only public interface is DerOutputStream.putOID()

     */

    void encode (DerOutputStream out) throws IOException

    {

        DerOutputStream bytes = new DerOutputStream ();

        int i;

        // According to ISO X.660, when the 1st component is 0 or 1, the 2nd

        // component is restricted to be less than or equal to 39, thus make

        // it small enough to be encoded into one single byte.

        if (components[0] < 2) {

            bytes.write ((components [0] * 40) + components [1]);

        } else {

            putComponent(bytes, (components [0] * 40) + components [1]);

        }

        for (i = 2; i < componentLen; i++)

            putComponent (bytes, components [i]);

        /*

         * Now that we've constructed the component, encode

         * it in the stream we were given.

         */

        out.write (DerValue.tag_ObjectId, bytes);

    }

    /*

     * Tricky OID component parsing technique ... note that one bit

     * per octet is lost, this returns at most 28 bits of component.

     * Also, notice this parses in big-endian format.

     */

    private static int getComponent (DerInputStream in)

    throws IOException

    {

        int retval, i, tmp;

        for (i = 0, retval = 0; i < 4; i++) {

            retval <<= 7;

            tmp = in.getByte ();

            retval |= (tmp & 0x07f);

            if ((tmp & 0x080) == 0)

                return retval;

        }

        throw new IOException ("ObjectIdentifier() -- component value too big");

    }

    /*

     * Reverse of the above routine.  Notice it needs to emit in

     * big-endian form, so it buffers the output until it's ready.

     * (Minimum length encoding is a DER requirement.)

     */

    private static void putComponent (DerOutputStream out, int val)

    throws IOException

    {

        int     i;

        // TODO: val must be <128*128*128*128 here, otherwise, 4 bytes is not

        // enough to hold it. Will address this later.

        byte    buf [] = new byte [4] ;

        for (i = 0; i < 4; i++) {

            buf [i] = (byte) (val & 0x07f);

            val >>>= 7;

            if (val == 0)

                break;

        }

        for ( ; i > 0; --i)

            out.write (buf [i] | 0x080);

        out.write (buf [0]);

    }

    // XXX this API should probably facilitate the JDK sort utility

    /**

     * Compares this identifier with another, for sorting purposes.

     * An identifier does not precede itself.

     *

     * @param other identifer that may precede this one.

     * @return true iff <em>other</em> precedes this one

     *          in a particular sorting order.

     */

    public boolean precedes (ObjectIdentifier other)

    {

        int             i;

        // shorter IDs go first

        if (other == this || componentLen < other.componentLen)

            return false;

        if (other.componentLen < componentLen)

            return true;

        // for each component, the lesser component goes first

        for (i = 0; i < componentLen; i++) {

            if (other.components [i] < components [i])

                return true;

        }

        // identical IDs don't precede each other

        return false;

    }

    /**

     * @deprecated Use equals((Object)oid)

     */

    @Deprecated

    public boolean equals(ObjectIdentifier other) {

        return equals((Object)other);

    }

    /**

     * Compares this identifier with another, for equality.

     *

     * @return true iff the names are identical.

     */

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj instanceof ObjectIdentifier == false) {

            return false;

        }

        ObjectIdentifier other = (ObjectIdentifier)obj;

        if (componentLen != other.componentLen) {

            return false;

        }

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

            if (components[i] != other.components[i]) {

                return false;

            }

        }

        return true;

    }

    public int hashCode() {

        int h = componentLen;

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

            h += components[i] * 37;

        }

        return h;

    }

    /**

     * Returns a string form of the object ID.  The format is the

     * conventional "dot" notation for such IDs, without any

     * user-friendly descriptive strings, since those strings

     * will not be understood everywhere.

     */

    public String toString() {

        String s = stringForm;

        if (s == null) {

            StringBuffer sb = new StringBuffer(componentLen * 4);

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

                if (i != 0) {

                    sb.append('.');

                }

                sb.append(components[i]);

            }

            s = sb.toString();

            stringForm = s;

        }

        return s;

    }

    /*

     * To simplify, we assume no individual component of an object ID is

     * larger than 32 bits.  Then we represent the path from the root as

     * an array that's (usually) only filled at the beginning.

     */

    private int         components [];                  // path from root

    private int         componentLen;                   // how much is used.

    private transient volatile String stringForm;

    private static final int allocationQuantum = 5;     // >= 2

}