/*

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

 *

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.security.ssl;

import java.io.*;

import java.nio.*;

import java.util.*;

import javax.crypto.BadPaddingException;

import javax.net.ssl.*;

/**

 * DTLS {@code InputRecord} implementation for {@code SSLEngine}.

 */

final class DTLSInputRecord extends InputRecord implements DTLSRecord {

    private DTLSReassembler reassembler = null;

        this.readEpoch = 0;

    }

    @Override

        this.readCipher = readCipher;

        this.readEpoch++;

    }

    @Override

    public synchronized void close() throws IOException {

        if (!isClosed) {

            super.close();

        }

    }

    @Override

    boolean isEmpty() {

        return ((reassembler == null) || reassembler.isEmpty());

    }

    @Override

    int estimateFragmentSize(int packetSize) {

        if (packetSize > 0) {

        } else {

            return Record.maxDataSize;

        }

    }

    @Override

    void expectingFinishFlight() {

        if (reassembler != null) {

            reassembler.expectingFinishFlight();

        }

    }

    @Override

    Plaintext acquirePlaintext() {

        if (reassembler != null) {

            return reassembler.acquirePlaintext();

        }

        return null;

    }

        if (isClosed) {

            return null;

        }

        }

        // The caller should have validated the record.

        int srcPos = packet.position();

        int srcLim = packet.limit();

        byte contentType = packet.get();                   // pos: 0

        byte majorVersion = packet.get();                  // pos: 1

        byte minorVersion = packet.get();                  // pos: 2

        byte[] recordEnS = new byte[8];                    // epoch + seqence

        packet.get(recordEnS);

        int recordEpoch = ((recordEnS[0] & 0xFF) << 8) |

                           (recordEnS[1] & 0xFF);          // pos: 3, 4

        long recordSeq  = ((recordEnS[2] & 0xFFL) << 40) |

                          ((recordEnS[3] & 0xFFL) << 32) |

                          ((recordEnS[4] & 0xFFL) << 24) |

                          ((recordEnS[5] & 0xFFL) << 16) |

                          ((recordEnS[6] & 0xFFL) <<  8) |

                           (recordEnS[7] & 0xFFL);         // pos: 5-10

        int contentLen = ((packet.get() & 0xFF) << 8) |

                          (packet.get() & 0xFF);           // pos: 11, 12

                    contentLen);

        }

        int recLim = srcPos + DTLSRecord.headerSize + contentLen;

            // Reset the position of the packet buffer.

            packet.position(recLim);

            }

            return null;

        }

        // Buffer next epoch message if necessary.

        if (this.readEpoch < recordEpoch) {

            // Discard the record younger than the current epcoh if:

            // 1. it is not a handshake message, or

                (this.readEpoch < (recordEpoch - 1))) {

                packet.position(recLim);

                }

                return null;

            }

            // Not ready to decrypt this record, may be an encrypted Finished

            // message, need to buffer it.

            byte[] fragment = new byte[contentLen];

            packet.get(fragment);              // copy the fragment

            RecordFragment buffered = new RecordFragment(fragment, contentType,

                    majorVersion, minorVersion,

                    recordEnS, recordEpoch, recordSeq, true);

            reassembler.queueUpFragment(buffered);

            // consume the full record in the packet buffer.

            packet.position(recLim);

        }

        //

        //

        // decrypt the fragment

        packet.limit(recLim);

        packet.position(srcPos + DTLSRecord.headerSize);

        ByteBuffer plaintextFragment;

        try {

            }

            // invalid, discard this record [section 4.1.2.7, RFC 6347]

            return null;

        } finally {

            // comsume a complete record

            packet.limit(srcLim);

            packet.position(recLim);

        }

                                                    // no retransmission

            // Cleanup the handshake reassembler if necessary.

            if ((reassembler != null) &&

                    (reassembler.handshakeEpoch < recordEpoch)) {

                }

                reassembler = null;

            }

        }

            if (reassembler == null) {

                reassembler = new DTLSReassembler(recordEpoch);

            }

            reassembler.queueUpChangeCipherSpec(

                    new RecordFragment(plaintextFragment, contentType,

                            majorVersion, minorVersion,

                            recordEnS, recordEpoch, recordSeq, false));

        } else {    // handshake record

            // One record may contain 1+ more handshake messages.

            while (plaintextFragment.remaining() > 0) {

                HandshakeFragment hsFrag = parseHandshakeMessage(

                    contentType, majorVersion, minorVersion,

                    recordEnS, recordEpoch, recordSeq, plaintextFragment);

                if (hsFrag == null) {

                    // invalid, discard this record

                    }

                    return null;

                }

                if (reassembler == null) {

                    reassembler = new DTLSReassembler(recordEpoch);

                }

                reassembler.queueUpHandshake(hsFrag);

            }

        }

        // Completed the read of the full record.  Acquire the reassembled

        // messages.

        if (reassembler != null) {

        }

        }

        return null;

    }

    @Override

        // DTLS length field is in bytes 11/12

        if (packet.remaining() < headerSize) {

            return -1;

        }

        // Last sanity check that it's not a wild record

        int pos = packet.position();

        // Check the content type of the record.

        byte contentType = packet.get(pos);

            throw new SSLException(

                    "Unrecognized SSL message, plaintext connection?");

        }

        // Check the protocol version of the record.

        // Get the fragment length of the record.

        int fragLen = ((packet.get(pos + 11) & 0xFF) << 8) +

                       (packet.get(pos + 12) & 0xFF) + headerSize;

        if (fragLen > Record.maxFragmentSize) {

            throw new SSLException(

                    "Record overflow, fragment length (" + fragLen +

                    ") MUST not exceed " + Record.maxFragmentSize);

        }

        return fragLen;

    }

    private static HandshakeFragment parseHandshakeMessage(

            byte contentType, byte majorVersion, byte minorVersion,

            byte[] recordEnS, int recordEpoch, long recordSeq,

            ByteBuffer plaintextFragment) {

        int remaining = plaintextFragment.remaining();

        if (remaining < handshakeHeaderSize) {

                        "too small record to hold a handshake fragment");

            }

            // invalid, discard this record [section 4.1.2.7, RFC 6347]

            return null;

        }

        byte handshakeType = plaintextFragment.get();       // pos: 0

        int messageLength =

                ((plaintextFragment.get() & 0xFF) << 16) |

                ((plaintextFragment.get() & 0xFF) << 8) |

                 (plaintextFragment.get() & 0xFF);          // pos: 1-3

        int messageSeq =

                ((plaintextFragment.get() & 0xFF) << 8) |

                 (plaintextFragment.get() & 0xFF);          // pos: 4/5

        int fragmentOffset =

                ((plaintextFragment.get() & 0xFF) << 16) |

                ((plaintextFragment.get() & 0xFF) << 8) |

                 (plaintextFragment.get() & 0xFF);          // pos: 6-8

        int fragmentLength =

                ((plaintextFragment.get() & 0xFF) << 16) |

                ((plaintextFragment.get() & 0xFF) << 8) |

                 (plaintextFragment.get() & 0xFF);          // pos: 9-11

        if ((remaining - handshakeHeaderSize) < fragmentLength) {

                        "not a complete handshake fragment in the record");

            }

            // invalid, discard this record [section 4.1.2.7, RFC 6347]

            return null;

        }

        byte[] fragment = new byte[fragmentLength];

        plaintextFragment.get(fragment);

        return new HandshakeFragment(fragment, contentType,

                majorVersion, minorVersion,

                recordEnS, recordEpoch, recordSeq,

                handshakeType, messageLength,

                messageSeq, fragmentOffset, fragmentLength);

    }

    // buffered record fragment

    private static class RecordFragment implements Comparable<RecordFragment> {

        boolean         isCiphertext;

        byte            contentType;

        byte            majorVersion;

        byte            minorVersion;

        int             recordEpoch;

        long            recordSeq;

        byte[]          recordEnS;

        byte[]          fragment;

        RecordFragment(ByteBuffer fragBuf, byte contentType,

                byte majorVersion, byte minorVersion, byte[] recordEnS,

                int recordEpoch, long recordSeq, boolean isCiphertext) {

            this((byte[])null, contentType, majorVersion, minorVersion,

                    recordEnS, recordEpoch, recordSeq, isCiphertext);

            this.fragment = new byte[fragBuf.remaining()];

            fragBuf.get(this.fragment);

        }

        RecordFragment(byte[] fragment, byte contentType,

                byte majorVersion, byte minorVersion, byte[] recordEnS,

                int recordEpoch, long recordSeq, boolean isCiphertext) {

            this.isCiphertext = isCiphertext;

            this.contentType = contentType;

            this.majorVersion = majorVersion;

            this.minorVersion = minorVersion;

            this.recordEpoch = recordEpoch;

            this.recordSeq = recordSeq;

            this.recordEnS = recordEnS;

            this.fragment = fragment;       // The caller should have cloned

                                            // the buffer if necessary.

        }

        @Override

        public int compareTo(RecordFragment o) {

                    // Only one incoming ChangeCipherSpec message for an epoch.

                    //

                    // Ignore duplicated ChangeCipherSpec messages.

                    return Integer.compare(this.recordEpoch, o.recordEpoch);

                } else if ((this.recordEpoch == o.recordEpoch) &&

                    // ChangeCipherSpec is the latest message of an epoch.

                    return 1;

                }

                if ((this.recordEpoch == o.recordEpoch) &&

                    // ChangeCipherSpec is the latest message of an epoch.

                    return -1;

                } else {

                    // different epoch or this is not a handshake message

                    return compareToSequence(o.recordEpoch, o.recordSeq);

                }

            }

            return compareToSequence(o.recordEpoch, o.recordSeq);

        }

        int compareToSequence(int epoch, long seq) {

            if (this.recordEpoch > epoch) {

                return 1;

            } else if (this.recordEpoch == epoch) {

                return Long.compare(this.recordSeq, seq);

            } else {

                return -1;

            }

        }

    }

    // buffered handshake message

    private static final class HandshakeFragment extends RecordFragment {

        byte            handshakeType;     // handshake msg_type

        int             messageSeq;        // message_seq

        int             messageLength;     // Handshake body length

        int             fragmentOffset;    // fragment_offset

        int             fragmentLength;    // fragment_length

        HandshakeFragment(byte[] fragment, byte contentType,

                byte majorVersion, byte minorVersion, byte[] recordEnS,

                int recordEpoch, long recordSeq,

                byte handshakeType, int messageLength,

                int messageSeq, int fragmentOffset, int fragmentLength) {

            super(fragment, contentType, majorVersion, minorVersion,

                    recordEnS, recordEpoch , recordSeq, false);

            this.handshakeType = handshakeType;

            this.messageSeq = messageSeq;

            this.messageLength = messageLength;

            this.fragmentOffset = fragmentOffset;

            this.fragmentLength = fragmentLength;

        }

        @Override

        public int compareTo(RecordFragment o) {

            if (o instanceof HandshakeFragment) {

                HandshakeFragment other = (HandshakeFragment)o;

                if (this.messageSeq != other.messageSeq) {

                    // keep the insertion order of handshake messages

                    return this.messageSeq - other.messageSeq;

                } else if (this.fragmentOffset != other.fragmentOffset) {

                    // small fragment offset was transmitted first

                    return this.fragmentOffset - other.fragmentOffset;

                } else if (this.fragmentLength == other.fragmentLength) {

                    // retransmissions, ignore duplicated messages.

                    return 0;

                }

                // Should be repacked for suitable fragment length.