/*

 * Copyright (c) 2000, 2006, 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 sun.security.jgss;

import org.ietf.jgss.GSSException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.IOException;

import sun.security.util.*;

/**

 * This class represents the mechanism independent part of a GSS-API

 * context establishment token. Some mechanisms may choose to encode

 * all subsequent tokens as well such that they start with an encoding

 * of an instance of this class. e.g., The Kerberos v5 GSS-API Mechanism

 * uses this header for all GSS-API tokens.

 * <p>

 * The format is specified in RFC 2743 section 3.1.

 *

 * @author Mayank Upadhyay

 */

/*

 * The RFC states that implementations should explicitly follow the

 * encoding scheme descibed in this section rather than use ASN.1

 * compilers. However, we should consider removing duplicate ASN.1

 * like code from here and depend on sun.security.util if possible.

 */

public class GSSHeader {

    private ObjectIdentifier mechOid = null;

    private byte[] mechOidBytes = null;

    private int mechTokenLength = 0;

    /**

     * The tag defined in the GSS-API mechanism independent token

     * format.

     */

    public static final int TOKEN_ID=0x60;

    /**

     * Creates a GSSHeader instance whose encoding can be used as the

     * prefix for a particular mechanism token.

     * @param mechOid the Oid of the mechanism which generated the token

     * @param mechTokenLength the length of the subsequent portion that

     * the mechanism will be adding.

     */

    public GSSHeader(ObjectIdentifier mechOid, int mechTokenLength)

        throws IOException {

        this.mechOid = mechOid;

        DerOutputStream temp = new DerOutputStream();

        temp.putOID(mechOid);

        mechOidBytes = temp.toByteArray();

        this.mechTokenLength = mechTokenLength;

    }

    /**

     * Reads in a GSSHeader from an InputStream. Typically this would be

     * used as part of reading the complete token from an InputStream

     * that is obtained from a socket.

     */

    public GSSHeader(InputStream is)

        throws IOException, GSSException {

        //      debug("Parsing GSS token: ");

        int tag = is.read();

        //      debug("tag=" + tag);

        if (tag != TOKEN_ID)

            throw new GSSException(GSSException.DEFECTIVE_TOKEN, -1,

                                   "GSSHeader did not find the right tag");

        int length = getLength(is);

        DerValue temp = new DerValue(is);

        mechOidBytes = temp.toByteArray();

        mechOid = temp.getOID();

        //      debug (" oid=" + mechOid);

        //      debug (" len starting with oid=" + length);

        mechTokenLength = length - mechOidBytes.length;

        //      debug("  mechToken length=" + mechTokenLength);

    }

    /**

     * Used to obtain the Oid stored in this GSSHeader instance.

     * @return the Oid of the mechanism.

     */

    public ObjectIdentifier getOid() {

        return mechOid;

    }

    /**

     * Used to obtain the length of the mechanism specific token that

     * will follow the encoding of this GSSHeader instance.

     * @return the length of the mechanism specific token portion that

     * will follow this GSSHeader.

     */

    public int getMechTokenLength() {

        return mechTokenLength;

    }

    /**

     * Used to obtain the length of the encoding of this GSSHeader.

     * @return the lenght of the encoding of this GSSHeader instance.

     */

    public int getLength() {

        int lenField = mechOidBytes.length + mechTokenLength;

        return (1 + getLenFieldSize(lenField) + mechOidBytes.length);

    }

    /**

     * Used to determine what the maximum possible mechanism token

     * size is if the complete GSSToken returned to the application

     * (including a GSSHeader) is not to exceed some pre-determined

     * value in size.

     * @param mechOid the Oid of the mechanism that will generate

     * this GSS-API token

     * @param maxTotalSize the pre-determined value that serves as a

     * maximum size for the complete GSS-API token (including a

     * GSSHeader)

     * @return the maximum size of mechanism token that can be used

     * so as to not exceed maxTotalSize with the GSS-API token

     */

    public static int getMaxMechTokenSize(ObjectIdentifier mechOid,

                                          int maxTotalSize) {

        int mechOidBytesSize = 0;

        try {

            DerOutputStream temp = new DerOutputStream();

            temp.putOID(mechOid);

            mechOidBytesSize = temp.toByteArray().length;

        } catch (IOException e) {

        }

        // Subtract bytes needed for 0x60 tag and mechOidBytes

        maxTotalSize -= (1 + mechOidBytesSize);

        // Subtract maximum len bytes

        maxTotalSize -= 5;

        return maxTotalSize;

        /*

         * Len field and mechanism token must fit in remaining

         * space. The range of the len field that we allow is

         * 1 through 5.

         *

         int mechTokenSize = 0;

         for (int lenFieldSize = 1; lenFieldSize <= 5;

         lenFieldSize++) {

         mechTokenSize = maxTotalSize - lenFieldSize;

         if (getLenFieldSize(mechTokenSize + mechOidBytesSize +

         lenFieldSize) <= lenFieldSize)

         break;

         }

         return mechTokenSize;

        */

    }

    /**

     * Used to determine the number of bytes that will be need to encode

     * the length field of the GSSHeader.

     */

    private int getLenFieldSize(int len) {

        int retVal = 1;

        if (len < 128) {

            retVal=1;

        } else if (len < (1 << 8)) {

            retVal=2;

        } else if (len < (1 << 16)) {

            retVal=3;

        } else if (len < (1 << 24)) {

            retVal=4;

        } else {

            retVal=5; // See getMaxMechTokenSize

        }

        return retVal;

    }

    /**

     * Encodes this GSSHeader instance onto the provided OutputStream.

     * @param os the OutputStream to which the token should be written.

     * @return the number of bytes that are output as a result of this

     * encoding

     */

    public int encode(OutputStream os) throws IOException {

        int retVal = 1 + mechOidBytes.length;

        os.write(TOKEN_ID);

        int length = mechOidBytes.length + mechTokenLength;

        retVal += putLength(length, os);

        os.write(mechOidBytes);

        return retVal;

    }

    /**

     * Get a length from the input stream, allowing for at most 32 bits of

     * encoding to be used. (Not the same as getting a tagged integer!)

     *

     * @return the length or -1 if indefinite length found.

     * @exception IOException on parsing error or unsupported lengths.

     */

    // shameless lifted from sun.security.util.DerInputStream.

    private int getLength(InputStream in) throws IOException {

        return getLength(in.read(), in);

    }

    /**

     * Get a length from the input stream, allowing for at most 32 bits of

     * encoding to be used. (Not the same as getting a tagged integer!)

     *

     * @return the length or -1 if indefinite length found.

     * @exception IOException on parsing error or unsupported lengths.

     */

    // shameless lifted from sun.security.util.DerInputStream.

    private int getLength(int lenByte, InputStream in) throws IOException {

        int value, tmp;

        tmp = lenByte;

        if ((tmp & 0x080) == 0x00) { // short form, 1 byte datum

            value = tmp;

        } else {                                         // long form or indefinite

            tmp &= 0x07f;

            /*

             * NOTE:  tmp == 0 indicates indefinite length encoded data.

             * tmp > 4 indicates more than 4Gb of data.

             */

            if (tmp == 0)

                return -1;

            if (tmp < 0 || tmp > 4)

                throw new IOException("DerInputStream.getLength(): lengthTag="

                                      + tmp + ", "

                                      + ((tmp < 0) ? "incorrect DER encoding." : "too big."));

            for (value = 0; tmp > 0; tmp --) {

                value <<= 8;

                value += 0x0ff & in.read();

            }

        }

        return value;

    }

    /**

     * Put the encoding of the length in the specified stream.

     *

     * @params len the length of the attribute.

     * @param out the outputstream to write the length to

     * @return the number of bytes written

     * @exception IOException on writing errors.

     */

    // Shameless lifted from sun.security.util.DerOutputStream.

    private int putLength(int len, OutputStream out) throws IOException {

        int retVal = 0;

        if (len < 128) {

            out.write((byte)len);

            retVal=1;

        } else if (len < (1 << 8)) {

            out.write((byte)0x081);

            out.write((byte)len);

            retVal=2;

        } else if (len < (1 << 16)) {

            out.write((byte)0x082);

            out.write((byte)(len >> 8));

            out.write((byte)len);

            retVal=3;

        } else if (len < (1 << 24)) {

            out.write((byte)0x083);

            out.write((byte)(len >> 16));

            out.write((byte)(len >> 8));

            out.write((byte)len);

            retVal=4;

        } else {

            out.write((byte)0x084);

            out.write((byte)(len >> 24));

            out.write((byte)(len >> 16));

            out.write((byte)(len >> 8));

            out.write((byte)len);

            retVal=5;

        }

        return retVal;

    }

    // XXX Call these two in some central class

    private void debug(String str) {

        System.err.print(str);

    }

    private  String getHexBytes(byte[] bytes, int len)

        throws IOException {

        StringBuffer sb = new StringBuffer();

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

            int b1 = (bytes[i]>>4) & 0x0f;

            int b2 = bytes[i] & 0x0f;

            sb.append(Integer.toHexString(b1));

            sb.append(Integer.toHexString(b2));

            sb.append(' ');

        }

        return sb.toString();

    }

}