smpp.rar_SMPP jar_SMPP java_smpp_smpp send ja_smpp3.4 java

package ie.omk.smpp; import ie.omk.smpp.event.ConnectionObserver; import ie.omk.smpp.event.EventDispatcher; import ie.omk.smpp.event.ReceiverExceptionEvent; import ie.omk.smpp.event.ReceiverExitEvent; import ie.omk.smpp.event.ReceiverStartEvent; import ie.omk.smpp.event.SMPPEvent; import ie.omk.smpp.event.SimpleEventDispatcher; import ie.omk.smpp.message.Bind; import ie.omk.smpp.message.BindResp; import ie.omk.smpp.message.DeliverSM; import ie.omk.smpp.message.DeliverSMResp; import ie.omk.smpp.message.EnquireLink; import ie.omk.smpp.message.EnquireLinkResp; import ie.omk.smpp.message.InvalidParameterValueException; import ie.omk.smpp.message.SMPPPacket; import ie.omk.smpp.message.SMPPProtocolException; import ie.omk.smpp.message.SMPPRequest; import ie.omk.smpp.message.SMPPResponse; import ie.omk.smpp.message.Unbind; import ie.omk.smpp.message.UnbindResp; import ie.omk.smpp.message.tlv.Tag; import ie.omk.smpp.net.SmscLink; import ie.omk.smpp.net.TcpLink; import ie.omk.smpp.util.APIConfig; import ie.omk.smpp.util.AlphabetEncoding; import ie.omk.smpp.util.DefaultSequenceScheme; import ie.omk.smpp.util.PacketFactory; import ie.omk.smpp.util.PropertyNotFoundException; import ie.omk.smpp.util.SMPPIO; import ie.omk.smpp.util.SequenceNumberScheme; import ie.omk.smpp.version.SMPPVersion; import ie.omk.smpp.version.VersionException; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.net.SocketTimeoutException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * SMPP client connection (ESME). An SMPP Connection represents any kind of * connection to the SMSC, be it a transmitter, receiver or transceiver. It also * supports both synchronous and asynchronous modes of communication. * Synchronous mode is only useful for very simple applications that use * single-threading. Asynchronous mode is recommended for more complex * applications, especially those that will be running many threads. * <p> * <b>Important Note </b>: if you wish to use synchronous mode in a * multi-threaded environment, it is the <u>application's </u> responsiblity to * ensure there is only one thread executing a call to either or both of the * <code>sendRequest</code> and <code>readNextPacket</code> methods. If * there are concurrent calls to these methods executing, there is a strong * possibility of the incorrect packet being returned in a particular thread and * both the API and the application getting confused. These are the only methods * that contain such a race condition. * </p> * * @author Oran Kelly * @version $Id: Connection.java 302 2006-08-10 20:36:40Z orank $ */ public class Connection implements java.lang.Runnable { /** SMPP Transmitter connection type. */ public static final int TRANSMITTER = 1; /** SMPP Receiver connection type. */ public static final int RECEIVER = 2; /** SMPP Transciever connection type. */ public static final int TRANSCEIVER = 3; /** Connection state: not bound to the SMSC. */ public static final int UNBOUND = 0; /** * Connection state: waiting for successful acknowledgement to bind request. */ public static final int BINDING = 1; /** Connection state: bound to the SMSC. */ public static final int BOUND = 2; /** * Connection state: waiting for successful acknowledgement to unbind * request or waiting for application to respond to unbind request. */ public static final int UNBINDING = 3; private static final Log LOGGER = LogFactory.getLog(Connection.class); /** Type of this SMPP connection. */ private int connectionType; /** Packet listener thread for Asyncronous comms. */ private Thread rcvThread; /** * Queue of incoming packets to deliver to application before reading from * the network. The queue is used only in syncrhonized mode. In the case * where an application has sent a request to the SMSC and is blocked * waiting a response and the SMSC initiates a request of it's own (an * unbind request or an enquire_link), the API will cache the request packet * and wait for the response to it's packet. Any other type of packet will * be added to the packetQueue and subsequent calls to * <code>readNextPacket</code> will clear this queue. */ private List packetQueue; /** * Object used to notify observers of SMPP events. */ private EventDispatcher eventDispatcher; /** Byte buffer used in readNextPacketInternal. */ private byte[] buf = new byte[300]; /** Sequence numbering scheme to use for this connection. */ private SequenceNumberScheme seqNumScheme = new DefaultSequenceScheme(); /** The network link (virtual circuit) to the SMSC */ private SmscLink link; /** * SMPP protocol version number. */ protected SMPPVersion interfaceVersion = SMPPVersion.getDefaultVersion(); /** * Does the remote end support optional parameters? According to the * SMPPv3.4 specification, if the SMSC does not return the * sc_interface_version optional parameter in its bind response packet, then * we must assume it does not support optional parameters. */ protected boolean supportOptionalParams = true; /** * Current state of the SMPP connection. Possible states are UNBOUND, * BINDING, BOUND and UNBINDING. */ private transient int state = UNBOUND; /** * Specify whether the listener thread will automatically ack enquire_link * primitives received from the Smsc */ protected boolean ackQryLinks = true; /** * Automatically acknowledge incoming deliver_sm messages. Only valid for * the Receiver */ protected boolean ackDeliverSm; /** Is the user using synchronous are async communication?. */ protected boolean asyncComms; /** * The default alphabet to use for this connection. */ protected AlphabetEncoding defaultAlphabet; /** * Initialise a new SMPP connection object. This is a convenience * constructor that will create a new {@link ie.omk.smpp.net.TcpLink}object * using the host name and port provided. The connection created will use * synchronous communications. * * @param host * the hostname of the SMSC. * @param port * the port to connect to. If 0, use the default SMPP port * number. */ public Connection(String host, int port) throws java.net.UnknownHostException { this(new TcpLink(host, port), false); } /** * Initialise a new SMPP connection object. This is a convenience * constructor that will create a new {@link ie.omk.smpp.net.TcpLink}object * using the host name and port provided. * * @param host * the hostname of the SMSC. * @param port * the port to connect to. If 0, use the default SMPP port * number. * @param async * true for asyncronous communication, false for synchronous. */ public Connection(String host, int port, boolean async) throws java.net.UnknownHostException { this(new TcpLink(host, port), async); } /** * Initialise a new SMPP connection object. The connection will use * synchronous communications. * * @param link * The network link object to the Smsc (cannot be null) */ public Connection(SmscLink link) { this(link, false); } /** * Initialise a new SMPP connection object, specifying the type of * communication desired. See the {@link Connection}class description for * some required knowledge on using the Connection in syncrhonous mode. * * @param link