datagramobject.java

用于移动设备上的java虚拟机源代码

/*
 * @(#)DatagramObject.java	1.29 02/09/11 @(#)
 *
 * Copyright (c) 1999-2002 Sun Microsystems, Inc.  All rights reserved.
 * PROPRIETARY/CONFIDENTIAL
 * Use is subject to license terms.
 */

package com.sun.midp.io.j2me.datagram;

import java.io.*;

import javax.microedition.io.*;

import com.sun.cldc.io.GeneralBase;

import com.sun.midp.io.HttpUrl;
import com.sun.midp.io.Util;

/**
 * Implements a UDP datagram for the UDP datagram connection.
 */
public class DatagramObject extends GeneralBase implements Datagram {

    /** Length of the hostname buffer. */
    private static final int MAX_HOST_LENGTH = 256;

    /** Buffer to be used. */
    private byte[] buffer;

    /** Where to start sending or receiving data. */
    private int offset;

    /** Number of bytes to send or receive. */
    private int length;

    /** Datagram address as a URL. */
    String address;

    /** Raw IPv4 address. */
    int ipNumber;

    /** UDP port */
    int port;

    /** Current read/write position in buffer. */
    private int readWritePosition;

    /**
     * Create a Datagram Object.
     *
     * @param  buf             The buffer to be used in the datagram
     * @param  len             The length of the buffer to be allocated
     *                         for the datagram
     */
    public DatagramObject(byte[] buf, int len) {
        setData(buf, 0, len);
    }

    /**
     * Get the address in the datagram.
     *
     * @return the address in string form, or null if no address was set
     *
     * @see #setAddress
     */
    public String getAddress() {
        return address;
    }

    /**
     * Get the buffer.
     *
     * @return the data buffer
     *
     * @see #setData
     */
    public byte[] getData() {
        return buffer;
    }

    /**
     * Get the a number that is either the number of bytes to send or the
     * number of bytes received.
     *
     * @return the length of the data
     *
     * @see #setLength
     */
    public int getLength() {
        return length;
    }

    /**
     * Get the offset.
     *
     * @return the offset into the data buffer
     */
    public int getOffset() {
        return offset;
    }

    /**
     * Set datagram address. Must a "datagram://" URI.
     * <p>
     * @param addr the new target address as a URL
     * @exception IllegalArgumentException if the address is not valid
     *
     * @see #getAddress
     */
    public void setAddress(String addr) {
        HttpUrl url;
        int temp;

	if (addr == null)  {
            throw new IllegalArgumentException("Invalid address");
        }

        url = new HttpUrl(addr);

        if (url.scheme == null || !url.scheme.equals("datagram")) {
            throw new IllegalArgumentException("Invalid scheme");
        }

        /*
         * Since we reused the HttpUrl parser, we must make sure that
         * there was nothing past the authority in the URL.
         */
        if (url.path != null || url.query != null || url.fragment != null) {
            throw new IllegalArgumentException("Malformed address");
        }

        port = url.port;

        if (url.host == null) {
            throw new IllegalArgumentException("Missing host");
        }
            
        if (port == -1) {
            throw new IllegalArgumentException("Missing port");
        }

        temp = Protocol.getIpNumber(Util.toCString(url.host));
        if (temp == -1) {
            throw new IllegalArgumentException("Invalid host");
        }

        ipNumber = temp;
        address = addr;
    }

    /**
     * Set datagram address, copying the address from another datagram.
     *
     * @param reference the datagram who's address will be copied as
     * the new target address for this datagram.
     * @exception IllegalArgumentException if the address is not valid
     *
     * @see #getAddress
     */
    public void setAddress(Datagram reference) {
        setAddress(reference.getAddress());
    }

    /**
     * Set the length. Which can represent either the number of bytes to send
     * or the maxium number of bytes to receive.
     *
     * @param len the new length of the data
     * @exception IllegalArgumentException if the length is negative
     * or larger than the buffer
     *
     * @see #getLength
     */
    public void setLength(int len) {
        setData(buffer, offset, len);
    }

    /**
     * Set the buffer, offset and length.
     *
     * @param buf the data buffer
     * @param off the offset into the data buffer
     * @param len the length of the data in the buffer
     * @exception IllegalArgumentException if the length or offset
     *                                     fall outside the buffer
     *
     * @see #getData
     */
    public void setData(byte[] buf, int off, int len) {
	/*
	 * Check that the offset and length are valid.
	 *   - must be positive
	 *   - must not exceed buffer length
	 *   - must have valid buffer
	 */
        if (len < 0 || off < 0 ||
	    (buf == null) ||
	    (off > 0 && off == buf.length) ||
            ((len + off) > buf.length)||
            ((len + off) < 0)) {
            throw new IllegalArgumentException("Illegal length or offset");
        }

        buffer = buf;
        offset = off;
        length = len;
    }

    /**
     * Zero the read/write pointer as well as the offset and
     * length parameters.
     */
    public void reset() {
        readWritePosition = 0;
        offset = 0;
        length = 0;
    }

    /**
     * A more effient <code>skip</code> than the one in
     * <code>GeneralBase</code>.
     * Skips over and discards <code>n</code> bytes of data from this input
     * stream. The <code>skip</code> method may, for a variety of reasons, end
     * up skipping over some smaller number of bytes, possibly <code>0</code>.
     * This may result from any of a number of conditions; reaching end of file
     * before <code>n</code> bytes have been skipped is only one possibility.
     * The actual number of bytes skipped is returned.  If <code>n</code> is
     * negative, no bytes are skipped.
     *
     *
     * @param      n   the number of bytes to be skipped.
     * @return     the actual number of bytes skipped.
     * @exception  IOException  if an I/O error occurs.
     */
    public long skip(long n) throws IOException {
        if (n < 0) {
            return 0;
        }

        if (readWritePosition >= length) {
            return 0;
        }

        int min = Math.min((int)n, length - readWritePosition);
        readWritePosition += min;
        return (min);
    }

    /**
     * Reads the next byte of data from the input stream. The value byte is
     * returned as an <code>int</code> in the range <code>0</code> to
     * <code>255</code>. If no byte is available because the end of the stream
     * has been reached, the value <code>-1</code> is returned. This method
     * blocks until input data is available, the end of the stream is detected,
     * or an exception is thrown.
     *
     * @return     the next byte of data, or <code>-1</code> if the end of the
     *             stream is reached.
     */
    public int read() {
        if (readWritePosition >= length) {
            return -1;
        }

        return buffer[offset + readWritePosition++] & 0xFF;
    }

    /**
     * Writes the specified byte to this output stream. The general
     * contract for <code>write</code> is that one byte is written
     * to the output stream. The byte to be written is the eight
     * low-order bits of the argument <code>b</code>. The 24
     * high-order bits of <code>ch</code> are ignored.
     *
     * @param      ch   the <code>byte</code>.
     * @exception  IOException  if an I/O error occurs. In particular,
     *             an <code>IOException</code> may be thrown if the
     *             buffer is full.
     */
    public void write(int ch) throws IOException {
        if (offset + readWritePosition >= buffer.length) {
            throw new IOException("Buffer full");
        }

        buffer[offset + readWritePosition++] = (byte)ch;
        length = readWritePosition;
    }
}