Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils.ntp;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

public final class Message {

    /** Maximum message length (in bytes), without authentication */

    public static final int MAXIMUM_LENGTH = 384;

    /** Leap Indicator. */

    private byte byLeapIndicator;

    /** Version Number. */

    private byte byVersionNumber = 0x04;

    /** Client mode. */

    private byte byMode = 0x03;

    /** Stratum. */

    private byte byStratum;

    /** Poll Interval. */

    private byte byPollInterval;

    /** Precision. */

    private byte byPrecision;

    /** Rood Delay. */

    private double dRootDelay;

    /** Root Dispersion. */

    private double dRootDispersion;

    /** Reference Identifier. */

    private byte[] sReferenceIdentifier = "LOCL".getBytes();

    /** Reference Timestamp. */

    private Timestamp tReferenceTimestamp = Timestamp.ZERO;

    /** Originate Timestamp. */

    private Timestamp tOriginateTimestamp = Timestamp.ZERO;

    /** Receive Timestamp. */

    private Timestamp tReceiveTimestamp = Timestamp.ZERO;

    /** Transmit Timestamp. */

    private Timestamp tTransmitTimestamp = Timestamp.ZERO;

    /**

     * Returns the Leap Indicator.

     *

     * @return the Leap Indicator.

     */

    public byte getLeapIndicator() {

        return byLeapIndicator;

    }

    /**

     * Sets the Leap Indicator.

     *

     * @param byLeapIndicator the Leap Indicator.

     */

    public void setLeapIndicator(final byte byLeapIndicator) {

        this.byLeapIndicator = byLeapIndicator;

    }

    /**

     * Returns the Version Number.

     *

     * @return the Version Number.

     */

    public byte getVersionNumber() {

        return byVersionNumber;

    }

    /**

     * Sets the Version Number.

     *

     * @param byVersionNumber the Version Number.

     */

    public void setVersionNumber(final byte byVersionNumber) {

        this.byVersionNumber = byVersionNumber;

    }

    /**

     * Returns the Mode.

     *

     * @return the Mode.

     */

    public byte getMode() {

        return byMode;

    }

    /**

     * Sets the Mode.

     *

     * @param byMode the Mode.

     */

    public void setMode(final byte byMode) {

        this.byMode = byMode;

    }

    /**

     * Returns the Stratum.

     *

     * @return the Stratum.

     */

    public byte getStratum() {

        return byStratum;

    }

    /**

     * Sets the Stratum.

     *

     * @param byStratum the Stratum.

     */

    public void setStratum(final byte byStratum) {

        this.byStratum = byStratum;

    }

    /**

     * Returns the Poll Interval.

     *

     * @return the Poll Interval.

     */

    public byte getPollInterval() {

        return byPollInterval;

    }

    /**

     * Sets the Poll Interval.

     *

     * @param byPollInterval the Poll Interval.

     */

    public void setPollInterval(final byte byPollInterval) {

        this.byPollInterval = byPollInterval;

    }

    /**

     * Returns the Precision.

     *

     * @return the Precision.

     */

    public byte getPrecision() {

        return byPrecision;

    }

    /**

     * Sets the Precision.

     *

     * @param byPrecision the Precision.

     */

    public void setPrecision(final byte byPrecision) {

        this.byPrecision = byPrecision;

    }

    /**

     * Returns the Root Delay.

     *

     * @return the Root Delay.

     */

    public double getRootDelay() {

        return dRootDelay;

    }

    /**

     * Sets the Root Delay.

     *

     * @param dRootDelay the Root Delay.

     */

    public void setRootDelay(final double dRootDelay) {

        this.dRootDelay = dRootDelay;

    }

    /**

     * Returns the Root Dispersion.

     *

     * @return the Root Dispersion.

     */

    public double getRootDispersion() {

        return dRootDispersion;

    }

    /**

     * Sets the Root Dispersion.

     *

     * @param dRootDispersion the Root Dispersion.

     */

    public void setRootDispersion(final double dRootDispersion) {

        this.dRootDispersion = dRootDispersion;

    }

    /**

     * Returns the Reference Identifier.

     *

     * @return the Reference Identifier.

     */

    public byte[] getReferenceIdentifier() {

        return sReferenceIdentifier;

    }

    /**

     * Sets the Reference Identifier.

     *

     * @param sReferenceIdentifier the Reference Identifier.

     */

    public void setReferenceIdentifier(final byte[] sReferenceIdentifier) {

        this.sReferenceIdentifier = sReferenceIdentifier;

    }

    /**

     * Returns the Reference Timestamp.

     *

     * @return the Reference Timestamp.

     */

    public Timestamp getReferenceTimestamp() {

        return tReferenceTimestamp;

    }

    /**

     * Sets the Reference Timestamp.

     *

     * @param tReferenceTimestamp the Reference Timestamp.

     */

    public void setReferenceTimestamp(final Timestamp tReferenceTimestamp) {

        this.tReferenceTimestamp = tReferenceTimestamp;

    }

    /**

     * Returns the Originate Timestamp.

     *

     * @return the Originate Timestamp.

     */

    public Timestamp getOriginateTimestamp() {

        return tOriginateTimestamp;

    }

    /**

     * Sets the Originate Timestamp.

     *

     * @param tOriginateTimestamp the Originate Timestamp.

     */

    public void setOriginateTimestamp(final Timestamp tOriginateTimestamp) {

        this.tOriginateTimestamp = tOriginateTimestamp;

    }

    /**

     * Returns the Receive Timestamp.

     *

     * @return the Receive Timestamp.

     */

    public Timestamp getReceiveTimestamp() {

        return tReceiveTimestamp;

    }

    /**

     * Sets the Receive Timestamp.

     *

     * @param tReceiveTimestamp the Receive Timestamp.

     */

    public void setReceiveTimestamp(final Timestamp tReceiveTimestamp) {

        this.tReceiveTimestamp = tReceiveTimestamp;

    }

    /**

     * Returns the Transmit Timestamp.

     *

     * @return the Transmit Timestamp.

     */

    public Timestamp getTransmitTimestamp() {

        return tTransmitTimestamp;

    }

    /**

     * Sets the Transmit Timestamp.

     *

     * @param tTransmitTimestamp the Transmit Timestamp.

     */

    public void setTransmitTimestamp(final Timestamp tTransmitTimestamp) {

        this.tTransmitTimestamp = tTransmitTimestamp;

    }

    /**

     * Encodes an SNTP message to a byte stream.

     *

     * @param output the byte stream.

     */

    public void encodeMessage(final OutputStream output) throws IOException {

        byte flags = (byte) (this.getLeapIndicator() << 6);

        flags += (byte) (this.getVersionNumber() << 3);

        flags += this.getMode();

        output.write(flags);

        output.write(this.getStratum());

        output.write(this.getPollInterval());

        output.write(this.getPrecision());

        encodeFixedPoint(this.getRootDelay(), output);

        encodeFixedPoint(this.getRootDispersion(), output);

        encodeBitstring(this.getReferenceIdentifier(), output);

        encodeTimestamp(this.getReferenceTimestamp(), output);

        encodeTimestamp(this.getOriginateTimestamp(), output);

        encodeTimestamp(this.getReceiveTimestamp(), output);

        encodeTimestamp(this.getTransmitTimestamp(), output);

    }

    /**

     * Decodes an SNTP message from a byte stream.

     *

     * @param input the byte stream.

     * @return the message.

     */

    public static Message decodeMessage(final InputStream input) throws IOException {

        final Message message = new Message();

        final byte flags = (byte) input.read();

        message.setLeapIndicator((byte) (flags >> 6));

        message.setVersionNumber((byte) ((flags >> 3) & 0x07));

        message.setMode((byte) (flags & 0x07));

        message.setStratum((byte) input.read());

        message.setPollInterval((byte) input.read());

        message.setPrecision((byte) input.read());

        message.setRootDelay(decodeFixedPoint(input));

        message.setRootDispersion(decodeFixedPoint(input));

        message.setReferenceIdentifier(decodeBitstring(input));

        message.setReferenceTimestamp(decodeTimestamp(input));

        message.setOriginateTimestamp(decodeTimestamp(input));

        message.setReceiveTimestamp(decodeTimestamp(input));

        message.setTransmitTimestamp(decodeTimestamp(input));

        return message;

    }

    /**

     * Encodes a 32 bit number to a byte stream.

     *

     * @param number the number to encode.

     * @param output the byte stream.

     * @throws IOException if an error occurs while writting to the stream.

     */

    private static void encode32(final long number, final OutputStream output) throws IOException {

        for (int i = 3; i >= 0; i--) {

            output.write((int) ((number >> (8 * i)) & 0xFF));

        }

    }

    /**

     * Decodes a 32 bit number from a byte stream.

     *

     * @param input the byte stream.

     * @return the decoded number.

     * @throws IOException if an error occurs while reading from the stream.

     */

    private static long decode32(final InputStream input) throws IOException {

        long number = 0;

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

            number = (number << 8) + input.read();

        }

        return number;

    }

    /**

     * Encodes a 32-bit bitstring to a byte stream.

     *

     * @param bitstring the bitstring to encode.

     * @param output the byte stream.

     * @throws IOException if an error occurs while writting to the stream.

     */

    private static void encodeBitstring(final byte[] bitstring, final OutputStream output) throws IOException {

        final byte[] temp = { 0, 0, 0, 0 };

        System.arraycopy(bitstring, 0, temp, 0, bitstring.length);

        output.write(temp);

    }

    /**

     * Decodes a 32-bit bitstring from a byte stream.

     *

     * @param input the byte stream.

     * @return the decoded string.

     * @throws IOException if an error occurs while reading from the stream.

     */

    private static byte[] decodeBitstring(final InputStream input) throws IOException {

        final byte[] bitstring = new byte[4];

        input.read(bitstring, 0, 4);

        return bitstring;

    }

    /**

     * Encodes a 32 bit fixed-point number to a byte stream.

     *

     * @param number the fixed-point number to encode.

     * @param output the byte stream.

     * @throws IOException if an error occurs while writting to the stream.

     */

    private static void encodeFixedPoint(final double number, final OutputStream output) throws IOException {

        encode32((long) (number * 0x10000L), output);

    }

    /**

     * Decodes a 32 bit fixed-point number from a byte stream. The binary point is between bits 15

     * and 16.

     *

     * @param input the byte stream.

     * @return the decoded fixed-point number.

     * @throws IOException if an error occurs while reading from the stream.

     */

    private static double decodeFixedPoint(final InputStream input) throws IOException {

        return ((double) decode32(input)) / 0x10000L;

    }

    /**

     * Encodes a timestamp to a byte stream.

     *

     * @param timestamp the timestamp to encode.

     * @param output the byte stream.

     * @throws IOException if an error occurs while writting to the stream.

     */

    private static void encodeTimestamp(final Timestamp timestamp, final OutputStream output) throws IOException {

        encode32(timestamp.getInteger(), output);

        encode32(timestamp.getFraction(), output);

    }

    /**

     * Decodes a timestamp from a byte stream.

     *

     * @param input the byte stream.

     * @return the decoded timestamp.

     * @throws IOException if an error occurs while reading from the stream.

     */

    private static Timestamp decodeTimestamp(final InputStream input) throws IOException {

        final long integer = decode32(input);

        final long fraction = decode32(input);

        return new Timestamp(integer, fraction);

    }

}