/*

 * Copyright 1998-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.x509;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.util.Arrays;

import sun.security.util.*;

/**

 * This class represents the OtherName as required by the GeneralNames

 * ASN.1 object. It supplies the generic framework to allow specific

 * Other Name types, and also provides minimal support for unrecognized

 * Other Name types.

 *

 * The ASN.1 definition for OtherName is:

 * <pre>

 * OtherName ::= SEQUENCE {

 *     type-id    OBJECT IDENTIFIER,

 *     value      [0] EXPLICIT ANY DEFINED BY type-id

 * }

 * </pre>

 * @author Hemma Prafullchandra

 */

public class OtherName implements GeneralNameInterface {

    private String name;

    private ObjectIdentifier oid;

    private byte[] nameValue = null;

    private GeneralNameInterface gni = null;

    private static final byte TAG_VALUE = 0;

    private int myhash = -1;

    /**

     * Create the OtherName object from a passed ObjectIdentfier and

     * byte array name value

     *

     * @param oid ObjectIdentifier of this OtherName object

     * @param value the DER-encoded value of the OtherName

     * @throws IOException on error

     */

    public OtherName(ObjectIdentifier oid, byte[] value) throws IOException {

        if (oid == null || value == null) {

            throw new NullPointerException("parameters may not be null");

        }

        this.oid = oid;

        this.nameValue = value;

        gni = getGNI(oid, value);

        if (gni != null) {

            name = gni.toString();

        } else {

            name = "Unrecognized ObjectIdentifier: " + oid.toString();

        }

    }

    /**

     * Create the OtherName object from the passed encoded Der value.

     *

     * @param derValue the encoded DER OtherName.

     * @exception IOException on error.

     */

    public OtherName(DerValue derValue) throws IOException {

        DerInputStream in = derValue.toDerInputStream();

        oid = in.getOID();

        DerValue val = in.getDerValue();

        nameValue = val.toByteArray();

        gni = getGNI(oid, nameValue);

        if (gni != null) {

            name = gni.toString();

        } else {

            name = "Unrecognized ObjectIdentifier: " + oid.toString();

        }

    }

    /**

     * Get ObjectIdentifier

     */

    public ObjectIdentifier getOID() {

        //XXXX May want to consider cloning this

        return oid;

    }

    /**

     * Get name value

     */

    public byte[] getNameValue() {

        return nameValue.clone();

    }

    /**

     * Get GeneralNameInterface

     */

    private GeneralNameInterface getGNI(ObjectIdentifier oid, byte[] nameValue)

            throws IOException {

        try {

            Class extClass = OIDMap.getClass(oid);

            if (extClass == null) {   // Unsupported OtherName

                return null;

            }

            Class[] params = { Object.class };

            Constructor cons = ((Class<?>)extClass).getConstructor(params);

            Object[] passed = new Object[] { nameValue };

            GeneralNameInterface gni =

                       (GeneralNameInterface)cons.newInstance(passed);

            return gni;

        } catch (Exception e) {

            throw (IOException)new IOException("Instantiation error: " + e).initCause(e);

        }

    }

    /**

     * Return the type of the GeneralName.

     */

    public int getType() {

        return GeneralNameInterface.NAME_ANY;

    }

    /**

     * Encode the Other name into the DerOutputStream.

     *

     * @param out the DER stream to encode the Other-Name to.

     * @exception IOException on encoding errors.

     */

    public void encode(DerOutputStream out) throws IOException {

        if (gni != null) {

            // This OtherName has a supported class

            gni.encode(out);

            return;

        } else {

            // This OtherName has no supporting class

            DerOutputStream tmp = new DerOutputStream();

            tmp.putOID(oid);

            tmp.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, TAG_VALUE), nameValue);

            out.write(DerValue.tag_Sequence, tmp);

        }

    }

    /**

     * Compares this name with another, for equality.

     *

     * @return true iff the names are identical.

     */

    public boolean equals(Object other) {

        if (this == other) {

            return true;

        }

        if (!(other instanceof OtherName)) {

            return false;

        }

        OtherName otherOther = (OtherName)other;

        if (!(otherOther.oid.equals(oid))) {

            return false;

        }

        GeneralNameInterface otherGNI = null;

        try {

            otherGNI = getGNI(otherOther.oid, otherOther.nameValue);

        } catch (IOException ioe) {

            return false;

        }

        boolean result;

        if (otherGNI != null) {

            try {

                result = (otherGNI.constrains(this) == NAME_MATCH);

            } catch (UnsupportedOperationException ioe) {

                result = false;

            }

        } else {

            result = Arrays.equals(nameValue, otherOther.nameValue);

        }

        return result;

    }

    /**

     * Returns the hash code for this OtherName.

     *

     * @return a hash code value.

     */

    public int hashCode() {

        if (myhash == -1) {

            myhash = 37 + oid.hashCode();

            for (int i = 0; i < nameValue.length; i++) {

                myhash = 37 * myhash + nameValue[i];

            }

        }

        return myhash;

    }

    /**

     * Convert the name into user readable string.

     */

    public String toString() {

        return "Other-Name: " + name;

    }

    /**

     * Return type of constraint inputName places on this name:<ul>

     *   <li>NAME_DIFF_TYPE = -1: input name is different type from name

     *       (i.e. does not constrain).

     *   <li>NAME_MATCH = 0: input name matches name.

     *   <li>NAME_NARROWS = 1: input name narrows name (is lower in the

     *       naming subtree)

     *   <li>NAME_WIDENS = 2: input name widens name (is higher in the

     *       naming subtree)

     *   <li>NAME_SAME_TYPE = 3: input name does not match or narrow name,

     *       but is same type.

     * </ul>.  These results are used in checking NameConstraints during

     * certification path verification.

     *

     * @param inputName to be checked for being constrained

     * @returns constraint type above

     * @throws UnsupportedOperationException if name is same type, but

     *         comparison operations are not supported for this name type.

     */

    public int constrains(GeneralNameInterface inputName) {

        int constraintType;

        if (inputName == null) {

            constraintType = NAME_DIFF_TYPE;

        } else if (inputName.getType() != NAME_ANY) {

            constraintType = NAME_DIFF_TYPE;

        } else {

            throw new UnsupportedOperationException("Narrowing, widening, "

                + "and matching are not supported for OtherName.");

        }

        return constraintType;

    }

    /**

     * Return subtree depth of this name for purposes of determining

     * NameConstraints minimum and maximum bounds.

     *

     * @returns distance of name from root

     * @throws UnsupportedOperationException if not supported for this name type

     */

    public int subtreeDepth() {

        throw new UnsupportedOperationException

            ("subtreeDepth() not supported for generic OtherName");

    }

}