smsclink.java

SMPP（点到点短消息协议）的java实现

            try {
                if (snoopOut != null) {
                    pak.writeTo(snoopOut);
                }
            } catch (IOException x) {
                LOGGER.warn("IOException writing to snoop output stream.", x);
            }

            pak.writeTo(out);
            if (autoFlush) {
                out.flush();
            }
        }
    }

    /**
     * Flush the output stream of the SMSC link.
     * 
     * @throws java.io.IOException
     *             If an exception occurs while flushing the output stream.
     */
    public void flush() throws java.io.IOException {
        if (out != null) {
            out.flush();
        }
    }

    /**
     * Get the auto flush behaviour of this link. The default behaviour is
     * defined in the smppapi properties file. If no properties are found at
     * runtime, the default behaviour is set to <code>true</code>.
     * 
     * @see #setAutoFlush
     * @see ie.omk.smpp.util.APIConfig
     */
    public boolean getAutoFlush() {
        return autoFlush;
    }

    /**
     * Set the auto flush behaviour of this link. If set to true, the link will
     * flush the output stream after every packet written. In high-load
     * environments this may be undesirable.
     * 
     * @see #getAutoFlush
     */
    public void setAutoFlush(boolean flush) {
        this.autoFlush = flush;
    }

    /**
     * Read the next SMPP packet from the SMSC. This method will block until a
     * full packet can be read from the SMSC. The caller should pass in a byte
     * array to read the packet into. If the passed in byte array is too small,
     * a new one will be allocated and returned to the caller.
     * 
     * @param array
     *            a byte array buffer to read the packet into.
     * @return the handle to the passed in buffer or the reallocated one.
     * @throws java.io.EOFException
     *             If the end of stream is reached before a full packet can be
     *             read.
     * @throws java.io.IOException
     *             If an exception occurs when reading the packet from the input
     *             stream.
     */
    public byte[] read(final byte[] array) throws IOException {
        if (in == null) {
            throw new IOException(LINK_NOT_UP_ERR);
        }

        byte[] buf = array;
        int count = 0;
        synchronized (readLock) {
            try {
                count = readBytes(buf, 0, 4, 16);
                int cmdLen = SMPPIO.bytesToInt(buf, 0, 4);
                if (cmdLen > buf.length) {
                    byte[] newbuf = new byte[cmdLen];
                    System.arraycopy(buf, 0, newbuf, 0, count);
                    buf = newbuf;
                }
                int remaining = cmdLen - count;
                readBytes(buf, count, remaining, remaining);
            } finally {
                dump(snoopIn, array, 0, count);
            }
        }
        return buf;
    }

    /**
     * Get the number of bytes currently available on the input stream.
     */
    public final int available() {
        try {
            synchronized (readLock) {
                return in.available();
            }
        } catch (IOException x) {
            LOGGER.debug("IOException in available", x);
            return 0;
        }
    }

    /**
     * Attempt to read the bytes for an SMPP packet from the inbound stream.
     * @param buf The buffer to read bytes in to.
     * @param offset The offset into buffer to begin writing bytes from.
     * @param maxLen The maximum number of bytes to read in.
     * @param minimum The minimum number of bytes to read before returning. Once
     * this method has read at least this number of bytes, it will return.
     * @return The number of bytes read by this method.
     * @throws IOException
     */
    private int readBytes(byte[] buf, int offset, int minimum, int maxLen) throws IOException {
        assert Thread.holdsLock(readLock);
        int ptr = in.read(buf, offset, maxLen);
        if (ptr < minimum) {
            if (ptr == -1) {
                throw new EOFException(END_OF_STREAM_ERR);
            }
            while (ptr < minimum) {
                int count = in.read(buf, offset + ptr, maxLen - ptr);
                if (count < 0) {
                    throw new EOFException(END_OF_STREAM_ERR);
                }
                ptr += count;
           }
        }
        return ptr;
    }
    
    /**
     * Dump bytes to an output stream.
     * 
     * @param s
     *            the stream to write to (if null, do nothing).
     * @param b
     *            the byte array to dump bytes from.
     * @param offset
     *            the offset in <code>b</code> to begin from.
     * @param len
     *            the number of bytes to dump.
     */
    private void dump(OutputStream s, byte[] b, int offset, int len) {
        try {
            if (s != null) {
                s.write(b, offset, len);
            }
        } catch (IOException x) {
            LOGGER.warn("Couldn't write incoming bytes to input snooper.", x);
        }
    }

    /**
     * Get the output stream of the virtual circuit.
     * 
     * @throws java.io.IOException
     *             If the output stream cannot be retrieved or the connection is
     *             not open.
     */
    protected abstract OutputStream getOutputStream()
            throws java.io.IOException;

    /**
     * Get the input stream of the virtual circuit.
     * 
     * @throws java.io.IOException
     *             If the input stream cannot be retrieved or the connection is
     *             not open.
     */
    protected abstract InputStream getInputStream() throws java.io.IOException;

    /**
     * Check whether or not the connection to the SMSC is open.
     */
    public abstract boolean isConnected();

    /**
     * Set the value for read timeout. A link implementation may support timing
     * out on blocking read operations. This method may be used to set such a
     * timeout. If the implementation does not support timeouts, it must throw
     * an <code>UnsuppertedOperationException<code>.
     * @param timeout the timeout value in milliseconds.
     * @throws UnsupportedOperationException if the implementation does not support
     * timeouts.
     * @deprecated Use setTimeout(int)
     */
    public void setTimeout(long timeout) {
        throw new UnsupportedOperationException(TIMEOUT_UNSUPPORTED_ERR);
    }

    /**
     * Set the value for read timeout. A link implementation may support timing
     * out on blocking read operations. This method may be used to set such a
     * timeout. If the implementation does not support timeouts, it must throw
     * an <code>UnsuppertedOperationException<code>.
     * @param timeout the timeout value in milliseconds.
     * @throws UnsupportedOperationException if the implementation does not support
     * timeouts.
     */
    public void setTimeout(int timeout) {
        throw new UnsupportedOperationException(TIMEOUT_UNSUPPORTED_ERR);
    }

    /**
     * Get the value for read timeout.
     * 
     * @see #setTimeout
     * @return the current value for read timeout.
     * @throws UnsupportedOperationException
     *             if the implementation does not support timeouts.
     */
    public int getTimeout() {
        throw new UnsupportedOperationException(TIMEOUT_UNSUPPORTED_ERR);
    }

    /**
     * Set the snooper streams. The snooper streams will receive every byte that
     * is either received or sent using this class. This functionality is
     * intended as a debugging aid for SMPP developers. It will be up to the
     * application using the API to provide valid output streams for the data to
     * be written to. Either or both of the streams may be set to null, which in
     * effect turns off snooping.
     * 
     * @param snoopIn
     *            stream to receive incoming bytes from the SMSC (may be null).
     * @param snoopOut
     *            stream to receive outgoing bytes to the SMSC (may be null).
     */
    public void setSnoopStreams(OutputStream snoopIn, OutputStream snoopOut) {
        this.snoopIn = snoopIn;
        this.snoopOut = snoopOut;
    }
}