/*

 * 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.ssl;

/**

 * {@code OutputRecord} implementation for {@code SSLEngine}.

 */

final class SSLEngineOutputRecord extends OutputRecord implements SSLRecord {

    private HandshakeFragment fragmenter = null;

    private boolean isTalkingToV2 = false;      // SSLv2Hello

    private ByteBuffer v2ClientHello = null;    // SSLv2Hello

    private boolean isCloseWaiting = false;

        this.packetSize = SSLRecord.maxRecordSize;

    }

    @Override

    public synchronized void close() throws IOException {

        if (!isClosed) {

                isCloseWaiting = true;

            } else {

                super.close();

            }

        }

    }

    @Override

    void encodeAlert(byte level, byte description) throws IOException {

    }

    @Override

    void encodeHandshake(byte[] source,

            int offset, int length) throws IOException {

        if (fragmenter == null) {

           fragmenter = new HandshakeFragment();

        }

        if (firstMessage) {

            firstMessage = false;

            if ((helloVersion == ProtocolVersion.SSL20Hello) &&

                                            //  5: recode header size

                (source[offset + 4 + 2 + 32] == 0)) {

                                            // V3 session ID is empty

                                            //  4: handshake header size

                                            //  2: client_version in ClientHello

                                            // 32: random in ClientHello

                // Double space should be big enough for the converted message.

                v2ClientHello = encodeV2ClientHello(

                        source, (offset + 4), (length - 4));

                v2ClientHello.position(2);     // exclude the header

                v2ClientHello.position(0);

                return;

            }

        }

        byte handshakeType = source[offset];

        }

        fragmenter.queueUpFragment(source, offset, length);

    }

    @Override

    void encodeChangeCipherSpec() throws IOException {

        if (fragmenter == null) {

           fragmenter = new HandshakeFragment();

        }

        fragmenter.queueUpChangeCipherSpec();

    }

    @Override

    void encodeV2NoCipher() throws IOException {

        isTalkingToV2 = true;

    }

    @Override

            ByteBuffer destination) throws IOException {

                    "(2^64-1 packets). Closing connection.");

            }

            throw new SSLHandshakeException("sequence number overflow");

        }

        }

        int dstLim = destination.limit();

        boolean isFirstRecordOfThePayload = true;

        int packetLeftSize = Math.min(maxRecordSize, packetSize);

        boolean needMorePayload = true;

        long recordSN = 0L;

        while (needMorePayload) {

            int fragLen;

            if (isFirstRecordOfThePayload && needToSplitPayload()) {

                needMorePayload = true;

                fragLen = 1;

                isFirstRecordOfThePayload = false;

            } else {

                needMorePayload = false;

                if (packetLeftSize > 0) {

                    fragLen = writeCipher.calculateFragmentSize(

                    fragLen = Math.min(fragLen, Record.maxDataSize);

                } else {

                    fragLen = Record.maxDataSize;

                }

                if (fragmentSize > 0) {

                    fragLen = Math.min(fragLen, fragmentSize);

                }

            }

            int dstPos = destination.position();

            int dstContent = dstPos + headerSize +

                                writeCipher.getExplicitNonceSize();

            destination.position(dstContent);

            int remains = Math.min(fragLen, destination.remaining());

            fragLen = 0;

            int srcsLen = offset + length;

            for (int i = offset; (i < srcsLen) && (remains > 0); i++) {

                int amount = Math.min(sources[i].remaining(), remains);

                int srcLimit = sources[i].limit();

                sources[i].limit(sources[i].position() + amount);

                destination.put(sources[i]);

                sources[i].limit(srcLimit);         // restore the limit

                remains -= amount;

                fragLen += amount;

                if (remains > 0) {

                    offset++;

                    length--;

                }

            }

            destination.limit(destination.position());

            destination.position(dstContent);

                        ", length = " + destination.remaining());

            }

            // Encrypt the fragment and wrap up a record.

                    dstPos, dstLim, headerSize,

                ByteBuffer temporary = destination.duplicate();

                temporary.limit(temporary.position());

                temporary.position(dstPos);

            }

            packetLeftSize -= destination.position() - dstPos;

            // remain the limit unchanged

            destination.limit(dstLim);

            if (isFirstAppOutputRecord) {

                isFirstAppOutputRecord = false;

            }

        }

    }

        if (isTalkingToV2) {              // SSLv2Hello

            // We don't support SSLv2.  Send an SSLv2 error message

            // so that the connection can be closed gracefully.

            //

            // Please don't change the limit of the destination buffer.

            destination.put(SSLRecord.v2NoCipher);

            }

            isTalkingToV2 = false;

        }

        if (v2ClientHello != null) {

            // deliver the SSLv2 format ClientHello message

            //

            // Please don't change the limit of the destination buffer.

                            ", WRITE: SSLv2 ClientHello message" +

                            ", length = " + v2ClientHello.remaining());

                }

                }

            }

            destination.put(v2ClientHello);

            v2ClientHello = null;

        }

        if (fragmenter != null) {

            return fragmenter.acquireCiphertext(destination);

        }

        return null;

    }

    @Override

    boolean isEmpty() {

        return (!isTalkingToV2) && (v2ClientHello == null) &&

    }

    // buffered record fragment

    private static class RecordMemo {

        byte            contentType;

        byte            majorVersion;

        byte            minorVersion;

        byte[]          fragment;

    }

    private static class HandshakeMemo extends RecordMemo {

        byte            handshakeType;

        int             acquireOffset;

    }

    final class HandshakeFragment {

        private LinkedList<RecordMemo> handshakeMemos = new LinkedList<>();

        void queueUpFragment(byte[] source,

                int offset, int length) throws IOException {

            HandshakeMemo memo = new HandshakeMemo();

            memo.majorVersion = protocolVersion.major;  // kick start version?

            memo.minorVersion = protocolVersion.minor;

            memo.encodeCipher = writeCipher;

            memo.handshakeType = source[offset];

            memo.acquireOffset = 0;

            memo.fragment = new byte[length - 4];       // 4: header size

                                                        //    1: HandshakeType

                                                        //    3: message length

            System.arraycopy(source, offset + 4, memo.fragment, 0, length - 4);

            handshakeMemos.add(memo);

        }

        void queueUpChangeCipherSpec() {

            RecordMemo memo = new RecordMemo();

            memo.majorVersion = protocolVersion.major;

            memo.minorVersion = protocolVersion.minor;

            memo.encodeCipher = writeCipher;

            memo.fragment = new byte[1];

            memo.fragment[0] = 1;

            handshakeMemos.add(memo);

        }

        Ciphertext acquireCiphertext(ByteBuffer dstBuf) throws IOException {

            if (isEmpty()) {

                return null;

            }

            RecordMemo memo = handshakeMemos.getFirst();

            HandshakeMemo hsMemo = null;

                hsMemo = (HandshakeMemo)memo;

            }

            // ChangeCipherSpec message is pretty small.  Don't worry about

            // the fragmentation of ChangeCipherSpec record.

            int fragLen;

            if (packetSize > 0) {

                fragLen = Math.min(maxRecordSize, packetSize);

                fragLen = memo.encodeCipher.calculateFragmentSize(

            } else {

                fragLen = Record.maxDataSize;

            }

            if (fragmentSize > 0) {

                fragLen = Math.min(fragLen, fragmentSize);

            }

            int dstPos = dstBuf.position();

            int dstLim = dstBuf.limit();

            int dstContent = dstPos + headerSize +

                                    memo.encodeCipher.getExplicitNonceSize();

            dstBuf.position(dstContent);

            if (hsMemo != null) {

                int remainingFragLen = fragLen;

                while ((remainingFragLen > 0) && !handshakeMemos.isEmpty()) {

                    int memoFragLen = hsMemo.fragment.length;

                    if (hsMemo.acquireOffset == 0) {

                        // Don't fragment handshake message header

                        if (remainingFragLen <= 4) {

                            break;

                        }

                        dstBuf.put(hsMemo.handshakeType);

                        dstBuf.put((byte)((memoFragLen >> 16) & 0xFF));

                        dstBuf.put((byte)((memoFragLen >> 8) & 0xFF));

                        dstBuf.put((byte)(memoFragLen & 0xFF));

                        remainingFragLen -= 4;

                    } // Otherwise, handshake message is fragmented.

                    int chipLen = Math.min(remainingFragLen,

                            (memoFragLen - hsMemo.acquireOffset));

                    dstBuf.put(hsMemo.fragment, hsMemo.acquireOffset, chipLen);

                    hsMemo.acquireOffset += chipLen;

                    if (hsMemo.acquireOffset == memoFragLen) {

                        handshakeMemos.removeFirst();

                        // still have space for more records?

                        if ((remainingFragLen > chipLen) &&

                                 !handshakeMemos.isEmpty()) {

                            // look for the next buffered record fragment

                            } else {

                                break;

                            }

                        }

                    }

                    remainingFragLen -= chipLen;

                }

            } else {

                fragLen = Math.min(fragLen, memo.fragment.length);

                dstBuf.put(memo.fragment, 0, fragLen);

                handshakeMemos.removeFirst();

            }

            dstBuf.limit(dstBuf.position());

            dstBuf.position(dstContent);

                        ", length = " + dstBuf.remaining());

            }

            // Encrypt the fragment and wrap up a record.

                    memo.contentType, dstBuf,

                    dstPos, dstLim, headerSize,

                    ProtocolVersion.valueOf(memo.majorVersion,

                ByteBuffer temporary = dstBuf.duplicate();

                temporary.limit(temporary.position());