Packet.java

// PART OF THE MACHINE SIMULATION. DO NOT CHANGE.

package nachos.machine;

/**
 * A link-layer packet.
 *
 * @see	nachos.machine.NetworkLink
 */
public class Packet {
    /**
     * Allocate a new packet to be sent, using the specified parameters.
     *
     * @param	dstLink		the destination link address.
     * @param	srcLink		the source link address.
     * @param	contents	the contents of the packet.
     */
    public Packet(int dstLink, int srcLink, byte[] contents)
    throws MalformedPacketException {
        // make sure the paramters are valid
        if (dstLink < 0 || dstLink >= linkAddressLimit ||
                srcLink < 0 || srcLink >= linkAddressLimit ||
                contents.length > maxContentsLength)
            throw new MalformedPacketException();

        this.dstLink = dstLink;
        this.srcLink = srcLink;
        this.contents = contents;

        packetBytes = new byte[headerLength + contents.length];

        packetBytes[0] = NetworkLink.networkID;
        packetBytes[1] = (byte) dstLink;
        packetBytes[2] = (byte) srcLink;
        packetBytes[3] = (byte) contents.length;

        // if java had subarrays, i'd use them. but System.arraycopy is ok...
        System.arraycopy(contents, 0, packetBytes, headerLength,
                         contents.length);
    }

    /**
     * Allocate a new packet using the specified array of bytes received from
     * the network.
     *
     * @param	packetBytes	the bytes making up this packet.
     */
    public Packet(byte[] packetBytes) throws MalformedPacketException {
        this.packetBytes = packetBytes;

        // make sure we have a valid header
        if (packetBytes.length < headerLength ||
                packetBytes[0] != NetworkLink.networkID ||
                packetBytes[1] < 0 || packetBytes[1] >= linkAddressLimit ||
                packetBytes[2] < 0 || packetBytes[2] >= linkAddressLimit ||
                packetBytes[3] < 0 || packetBytes[3] > packetBytes.length-4)
            throw new MalformedPacketException();

        dstLink = packetBytes[1];
        srcLink = packetBytes[2];

        contents = new byte[packetBytes[3]];
        System.arraycopy(packetBytes, headerLength, contents, 0,
                         contents.length);
    }

    /** This packet, as an array of bytes that can be sent on a network. */
    public byte[] packetBytes;
    /** The address of the destination link of this packet. */
    public int dstLink;
    /** The address of the source link of this packet. */
    public int srcLink;
    /** The contents of this packet, excluding the link-layer header. */
    public byte[] contents;

    /**
     * The number of bytes in a link-layer packet header. The header is
     * formatted as follows:
     *
     * <table>
     * <tr><td>offset</td><td>size</td><td>value</td></tr>
     * <tr><td>0</td><td>1</td><td>network ID (collision detecting)</td></tr>
     * <tr><td>1</td><td>1</td><td>destination link address</td></tr>
     * <tr><td>2</td><td>1</td><td>source link address</td></tr>
     * <tr><td>3</td><td>1</td><td>length of contents</td></tr>
     * </table>
     */
    public static final int headerLength = 4;
    /**
     * The maximum length, in bytes, of a packet that can be sent or received
     * on the network.
     */
    public static final int maxPacketLength = 32;
    /**
     * The maximum number of content bytes (not including the header). Note
     * that this is just <tt>maxPacketLength - headerLength</tt>.
     */
    public static final int maxContentsLength = maxPacketLength - headerLength;

    /**
     * The upper limit on Nachos link addresses. All link addresses fall
     * between <tt>0</tt> and <tt>linkAddressLimit - 1</tt>.
     */
    public static final int linkAddressLimit = 128;
}