diff --git a/ASyncSocketClient.cs b/ASyncSocketClient.cs
new file mode 100644
index 0000000..9a4962d
--- /dev/null
+++ b/ASyncSocketClient.cs
@@ -0,0 +1,382 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Net.Sockets;
+
+namespace RoaminSMPP
+{
+	/// <summary>
+	/// Socket class for asynchronous connection.
+	/// </summary>
+	internal class AsyncSocketClient : IDisposable
+	{
+		#region delegates
+
+		/// <summary>
+		/// Called when a message is received.
+		/// </summary>
+		/// <param name="asyncSocketClient">
+		/// The AsyncSocketClient to receive messages from.
+		/// </param>
+		public delegate void MessageHandler(AsyncSocketClient asyncSocketClient);
+	
+		/// <summary>
+		/// Called when a connection is closed.
+		/// </summary>
+		/// <param name="asyncSocketClient">
+		/// The AsyncSocketClient to receive messages from.
+		/// </param>
+		public delegate void SocketClosingHandler(
+			AsyncSocketClient asyncSocketClient);
+	
+		/// <summary>
+		/// Called when a socket error occurs.
+		/// </summary>
+		/// <param name="asyncSocketClient">
+		/// The AsyncSocketClient to receive messages from.
+		/// </param>
+		/// <param name="exception">
+		/// The exception that generated the error.
+		/// </param>
+		public delegate void ErrorHandler(
+			AsyncSocketClient asyncSocketClient, Exception exception);
+	
+		#endregion delegates
+		//one MB
+		private const int BUFFER_SIZE = 1048576;
+
+		#region private fields
+
+		private NetworkStream _NetworkStream;
+		private TcpClient _TcpClient;
+		private AsyncCallback _CallbackReadMethod;
+		private AsyncCallback _CallbackWriteMethod;
+		private MessageHandler _MessageHandler;
+		private SocketClosingHandler _SocketCloseHandler;
+		private ErrorHandler _ErrorHandler;
+		private bool _IsDisposed;
+		private string _ServerIPAddress;
+		private Int16 _ServerPort;
+		private object _StateObject;
+		private byte[] _Buffer;
+		//private int clientBufferSize;
+
+		#endregion private fields
+
+		#region properties
+
+		/// <summary>
+		/// The server IP address to connect to.
+		/// </summary>
+		public string ServerIPAddress
+		{
+			get
+			{
+				return _ServerIPAddress;
+			}
+		}
+
+		/// <summary>
+		/// The server port to connect to.
+		/// </summary>
+		public Int16 ServerPort
+		{
+			get
+			{
+				return _ServerPort;
+			}
+		}
+
+		/// <summary>
+		/// A user set state object to associate some state with a connection.
+		/// </summary>
+		public object StateObject
+		{
+			get
+			{
+				return _StateObject;
+			}
+			set
+			{
+				_StateObject = value;
+			}
+		}
+
+		/// <summary>
+		/// Buffer to hold data coming in from the socket.
+		/// </summary>
+		public byte[] Buffer
+		{
+			get
+			{
+				return _Buffer;
+			}
+		}
+
+		#endregion properties
+
+		/// <summary>
+		/// Constructs an AsyncSocketClient.
+		/// </summary>
+		/// <param name="bufferSize">The size of the receive buffer.</param>
+		/// <param name="stateObject">The object to use for sending state
+		/// information.</param>
+		/// <param name="msgHandler">The user-defined message handling method.
+		/// </param>
+		/// <param name="closingHandler">The user-defined socket closing
+		/// handling method.</param>
+		/// <param name="errHandler">The user defined error handling method.
+		/// </param>
+		public AsyncSocketClient(Int32 bufferSize, object stateObject,
+		                         MessageHandler msgHandler, SocketClosingHandler closingHandler,
+		                         ErrorHandler errHandler)
+		{
+			//allocate buffer
+//			clientBufferSize = bufferSize;
+//			_Buffer = new byte[clientBufferSize];
+
+			_Buffer = new byte[BUFFER_SIZE];
+			_StateObject = stateObject;
+
+			//set handlers
+			_MessageHandler = msgHandler;
+			_SocketCloseHandler = closingHandler;
+			_ErrorHandler = errHandler;
+
+			//set the asynchronous method handlers
+			_CallbackReadMethod = new AsyncCallback(ReceiveComplete);
+			_CallbackWriteMethod = new AsyncCallback(SendComplete);
+
+			//haven't been disposed yet
+			_IsDisposed = false;
+		}
+
+		/// <summary>
+		/// Finalizer method.  If Dispose() is called correctly, there is nothing
+		/// for this to do.
+		/// </summary>
+		~AsyncSocketClient()
+		{
+			if (!_IsDisposed)
+			{
+				Dispose();
+			}
+		}
+
+		#region public methods
+
+		/// <summary>
+		/// Sets the disposed flag to true and disconnects the socket.
+		/// </summary>
+		public void Dispose()
+		{
+			try
+			{
+				_IsDisposed = true;
+				Disconnect();
+			}
+			catch
+			{}
+		}
+
+		/// <summary>
+		/// Connects the socket to the given IP address and port.
+		/// This also calls Receive().
+		/// </summary>
+		/// <param name="IPAddress">The IP address of the server.</param>
+		/// <param name="port">The port to connect to.</param>
+		public void Connect(String IPAddress, Int16 port)
+		{
+			try
+			{
+				//do we already have an open connection?
+				if (_NetworkStream == null)
+				{
+					_ServerIPAddress = IPAddress;
+					_ServerPort = port;
+
+					//attempt to establish the connection
+					_TcpClient = new TcpClient(_ServerIPAddress, _ServerPort);
+					_NetworkStream = _TcpClient.GetStream();
+
+					//set some socket options
+					_TcpClient.ReceiveBufferSize = BUFFER_SIZE;
+					_TcpClient.SendBufferSize = BUFFER_SIZE;
+					_TcpClient.NoDelay = true;
+					//if the connection is dropped, drop all associated data
+					_TcpClient.LingerState = new LingerOption(false, 0);
+
+					//start receiving messages
+					Receive();
+				}
+			}
+			catch (SocketException exc)
+			{
+				//the connect failed..pass the word on
+				throw new Exception(exc.Message, exc.InnerException);
+			}
+		}
+
+		///<summary>
+		/// Disconnects from the server.
+		/// </summary>
+		public void Disconnect()
+		{
+			//close down the connection, making sure it exists first
+			if (_NetworkStream != null)
+			{
+				_NetworkStream.Close();
+			}
+			if (_TcpClient != null)
+			{
+				_TcpClient.Close();
+			}
+
+			//prep for garbage collection-we may want to use this instance again
+			_NetworkStream = null;
+			_TcpClient = null;
+
+		}
+
+		///<summary>
+		/// Asynchronously sends data across the socket.
+		/// </summary>
+		/// <param name="buffer">
+		/// The buffer of data to send.
+		/// </param>
+		public void Send(byte[] buffer)
+		{
+			//send the data; don't worry about receiving any state information
+			//back;
+			try
+			{
+				if (_NetworkStream != null && _NetworkStream.CanWrite)
+				{
+					_NetworkStream.BeginWrite(
+						buffer, 0, buffer.Length, _CallbackWriteMethod, null);
+				}
+				else
+				{
+					throw new Exception("Socket is closed, cannot Send().");
+				}
+			}
+			catch
+			{
+				throw;
+			}
+		}
+
+		/// <summary>
+		/// Asynchronously receives data from the socket.
+		/// </summary>
+		public void Receive()
+		{
+			try
+			{
+				if (_NetworkStream != null && _NetworkStream.CanRead)
+				{
+					//_Buffer = new byte[clientBufferSize];
+					_Buffer = new byte[BUFFER_SIZE];
+					
+					_NetworkStream.BeginRead(
+						_Buffer, 0, _Buffer.Length, _CallbackReadMethod, null);
+				}
+				else
+				{
+					throw new Exception("Socket is closed, cannot Receive().");
+				}
+			}
+			catch
+			{
+				throw;
+			}
+		}
+
+		#endregion public methods
+
+		#region private methods
+
+		/// <summary>
+		/// Callback method called by the NetworkStream's thread when a message
+		/// is sent.
+		/// </summary>
+		/// <param name="state">The state object holding information about
+		/// the connection.</param>
+		private void SendComplete(IAsyncResult state)
+		{
+			try
+			{
+				//check to be sure the network stream is valid before writing
+				if (_NetworkStream.CanWrite)
+				{
+					_NetworkStream.EndWrite(state);
+				}
+			}
+			catch
+			{}
+		}
+
+		/// <summary>
+		/// Callback method called by the NetworkStream's thread when a message
+		/// arrives.
+		/// </summary>
+		/// <param name="state">The state object holding information about
+		/// the connection.</param>
+		private void ReceiveComplete(IAsyncResult state)
+		{
+			try
+			{
+				//check the stream to be sure it is valid
+				if (_NetworkStream.CanRead)
+				{
+					int bytesReceived = _NetworkStream.EndRead(state);
+
+					//if there are bytes to process, do so.  Otherwise, the
+					//connection has been lost, so clean it up
+					if (bytesReceived > 0)
+					{
+						try
+						{
+							//send the incoming message to the message handler
+							_MessageHandler(this);
+						}
+						finally
+						{
+							//start listening again
+							Receive();
+						}
+					}
+				}
+			}
+			catch
+			{
+				//the connection has been dropped so call the CloseHandler
+				try
+				{
+					_SocketCloseHandler(this);
+				}
+				finally
+				{
+					Dispose();
+				}
+			}
+		}
+		#endregion private methods
+	}
+}
diff --git a/AssemblyInfo.cs b/AssemblyInfo.cs
new file mode 100644
index 0000000..0fc3ec0
--- /dev/null
+++ b/AssemblyInfo.cs
@@ -0,0 +1,57 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]	
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.4")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//  (*)If no key is specified, the assembly is not signed.
+//  (*)KeyName refers to a key that has been installed in the Crypto Service
+//       Provider(CSP)on your machine. KeyFile refers to a file which contains
+//       a key.
+//  (*)If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//      (1)If the KeyName can be found in the CSP, that key is used.
+//      (2)If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//  (*)In order to create a KeyFile, you can use the sn.exe(Strong Name)utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//  (*)Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/CHANGELOG.txt b/CHANGELOG.txt
new file mode 100644
index 0000000..08e8652
--- /dev/null
+++ b/CHANGELOG.txt
@@ -0,0 +1,22 @@
+10/11/2008 : License changed to GNU Lesser General Public License, V3.  This should make combination with other (older) open source licenses such as the original BSD license possible.
+
+11/13/2006 : Added the remainder of the code to the project; I will no longer be working on this app.
+
+08/13/2005 : I've replaced much of the older code with new (hopefully more useful) code.  This 
+new set of namespaces includes both incoming and outgoing functionality for all the PDUs.  Note also 
+that this release is GPL only-I have dropped the QPL portion of the license from here on out. I 
+also fixed the dates on this changelog-for some reason I had them a year off.
+
+08/20/2004 : Host of changes.  The PDUFactory and several incoming PDUs were changed
+for compatibility after some testing.  Added some documentation tags.  Fixed TLVTable 
+so that null tags are simply dropped (i.e. trying to set an optional param to null 
+does nothing).  Also added the debug file and xml file to the binary release.  Also
+changed the zip files so that they store relative path info rather than full path info
+(to those of you who downloaded the early release-sorry about that).
+
+08/15/2004 : Changed the PDUFactory so that it allows multiple responses to come in on
+a PDU.  Also fixed the TrimResponsePDU() so that it didn't break if the command length 
+was too large (the null SMSC I was testing with today sent some out like that.  Also 
+included a build script.
+
+08/14/2004 : Initial release.
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..10926e8
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,675 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
diff --git a/COPYING.LESSER b/COPYING.LESSER
new file mode 100644
index 0000000..3f7b8b1
--- /dev/null
+++ b/COPYING.LESSER
@@ -0,0 +1,166 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
diff --git a/EventObject/AlertEventArgs.cs b/EventObject/AlertEventArgs.cs
new file mode 100644
index 0000000..5c24768
--- /dev/null
+++ b/EventObject/AlertEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines the bind event.  Includes all the available
+	/// mandatory and optional parameters in a bind_response.
+	/// </summary>
+	public class AlertEventArgs : SmppEventArgs 
+	{
+		private SmppAlertNotification _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppAlertNotification AlertPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the AlertEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppAlertNotification.</param>
+		internal AlertEventArgs(SmppAlertNotification response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/BindEventArgs.cs b/EventObject/BindEventArgs.cs
new file mode 100644
index 0000000..1035bfc
--- /dev/null
+++ b/EventObject/BindEventArgs.cs
@@ -0,0 +1,52 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet.Request;
+
+namespace RoaminSMPP.EventObjects
+{
+	/// <summary>
+	/// Class that defines the bind_sm event.
+	/// </summary>
+	public class BindEventArgs : SmppEventArgs 
+	{
+		private SmppBind _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppBind BindPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the BindEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppBindResp.</param>
+		internal BindEventArgs(SmppBind response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/BindRespEventArgs.cs b/EventObject/BindRespEventArgs.cs
new file mode 100644
index 0000000..c721360
--- /dev/null
+++ b/EventObject/BindRespEventArgs.cs
@@ -0,0 +1,52 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines the bind_sm_resp event.
+	/// </summary>
+	public class BindRespEventArgs : SmppEventArgs 
+	{
+		private SmppBindResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppBindResp BindRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the BindEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppBindResp.</param>
+		internal BindRespEventArgs(SmppBindResp response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/CancelEventArgs.cs b/EventObject/CancelEventArgs.cs
new file mode 100644
index 0000000..ab76f93
--- /dev/null
+++ b/EventObject/CancelEventArgs.cs
@@ -0,0 +1,53 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines a cancel_sm_resp event.
+	/// </summary>
+	public class CancelEventArgs : SmppEventArgs 
+	{
+		private SmppCancelSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppCancelSmResp CancelPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the CancelEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppCancelSmResp.</param>
+		internal CancelEventArgs(SmppCancelSmResp response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/CancelSmEventArgs.cs b/EventObject/CancelSmEventArgs.cs
new file mode 100644
index 0000000..ee7de73
--- /dev/null
+++ b/EventObject/CancelSmEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a cancel_sm event.
+	/// </summary>
+	public class CancelSmEventArgs : SmppEventArgs 
+	{
+		private SmppCancelSm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppCancelSm CancelSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a CancelSmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal CancelSmEventArgs(SmppCancelSm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/CancelSmRespEventArgs.cs b/EventObject/CancelSmRespEventArgs.cs
new file mode 100644
index 0000000..0b0fb98
--- /dev/null
+++ b/EventObject/CancelSmRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+using RoaminSMPP.Packet.Response;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a cancel_sm_resp event.
+	/// </summary>
+	public class CancelSmRespEventArgs : SmppEventArgs 
+	{
+		private SmppCancelSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppCancelSmResp CancelSmRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a CancelSmRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal CancelSmRespEventArgs(SmppCancelSmResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/CommonErrorEventArgs.cs b/EventObject/CommonErrorEventArgs.cs
new file mode 100644
index 0000000..c72be81
--- /dev/null
+++ b/EventObject/CommonErrorEventArgs.cs
@@ -0,0 +1,51 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Event args class.  Holds the internal exception generated.
+	/// </summary>
+	public class CommonErrorEventArgs : System.EventArgs 
+	{
+		private Exception _exc;
+
+		/// <summary>
+		/// The thrown exception.
+		/// </summary>
+		public Exception ThrownException 
+		{
+			get 
+			{
+				return _exc;
+			}
+		}
+
+		/// <summary>
+		/// Creates an CommErrorEventArgs.
+		/// </summary>
+		/// <param name="exc">The exception that was generated.</param>
+		public CommonErrorEventArgs(Exception exc)
+		{
+			_exc = exc;
+		}
+	}
+}
diff --git a/EventObject/DataSmEventArgs.cs b/EventObject/DataSmEventArgs.cs
new file mode 100644
index 0000000..54ea598
--- /dev/null
+++ b/EventObject/DataSmEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a data_sm event.  
+	/// </summary>
+	public class DataSmEventArgs : SmppEventArgs 
+	{
+		private SmppDataSm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppDataSm DataSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a DataSmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal DataSmEventArgs(SmppDataSm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/DataSmRespEventArgs.cs b/EventObject/DataSmRespEventArgs.cs
new file mode 100644
index 0000000..cbaa9d2
--- /dev/null
+++ b/EventObject/DataSmRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a data_sm_resp event.
+	/// </summary>
+	public class DataSmRespEventArgs : SmppEventArgs 
+	{
+		private SmppDataSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppDataSmResp DataSmRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a DataSmRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal DataSmRespEventArgs(SmppDataSmResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/DeliverSmEventArgs.cs b/EventObject/DeliverSmEventArgs.cs
new file mode 100644
index 0000000..e5ba47d
--- /dev/null
+++ b/EventObject/DeliverSmEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a deliver_sm event.  
+	/// </summary>
+	public class DeliverSmEventArgs : SmppEventArgs 
+	{
+		private SmppDeliverSm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppDeliverSm DeliverSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a DeliverSmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal DeliverSmEventArgs(SmppDeliverSm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/DeliverSmRespEventArgs.cs b/EventObject/DeliverSmRespEventArgs.cs
new file mode 100644
index 0000000..f06a4ac
--- /dev/null
+++ b/EventObject/DeliverSmRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a deliver_sm_resp event.
+	/// </summary>
+	public class DeliverSmRespEventArgs : SmppEventArgs 
+	{
+		private SmppDeliverSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppDeliverSmResp DeliverSmRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a DeliverSmRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal DeliverSmRespEventArgs(SmppDeliverSmResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/EnquireLinkEventArgs.cs b/EventObject/EnquireLinkEventArgs.cs
new file mode 100644
index 0000000..dc26012
--- /dev/null
+++ b/EventObject/EnquireLinkEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines the enquire_link event.
+	/// </summary>
+	public class EnquireLinkEventArgs : SmppEventArgs 
+	{
+		private SmppEnquireLink _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppEnquireLink EnquireLinkPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the EnquireLinkEventArgs.
+		/// </summary>
+		/// <param name="response">The PDU from the ESME.</param>
+		internal EnquireLinkEventArgs(SmppEnquireLink response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/EnquireLinkRespEventArgs.cs b/EventObject/EnquireLinkRespEventArgs.cs
new file mode 100644
index 0000000..f3932e0
--- /dev/null
+++ b/EventObject/EnquireLinkRespEventArgs.cs
@@ -0,0 +1,52 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines the enquire_link_resp event.
+	/// </summary>
+	public class EnquireLinkRespEventArgs : SmppEventArgs 
+	{
+		private SmppEnquireLinkResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppEnquireLinkResp EnquireLinkRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the EnquireLinkEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppEnquireLinkResp.</param>
+		internal EnquireLinkRespEventArgs(SmppEnquireLinkResp response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/GenericNackEventArgs.cs b/EventObject/GenericNackEventArgs.cs
new file mode 100644
index 0000000..10bd05a
--- /dev/null
+++ b/EventObject/GenericNackEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a generic_nack event.
+	/// </summary>
+	public class GenericNackEventArgs : SmppEventArgs 
+	{
+		private SmppGenericNack _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppGenericNack GenericNackPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a GenericNackEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal GenericNackEventArgs(SmppGenericNack packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/QuerySmEventArgs.cs b/EventObject/QuerySmEventArgs.cs
new file mode 100644
index 0000000..5d82202
--- /dev/null
+++ b/EventObject/QuerySmEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a query_sm event.  
+	/// </summary>
+	public class QuerySmEventArgs : SmppEventArgs 
+	{
+		private SmppQuerySm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppQuerySm QuerySmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a QuerySmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal QuerySmEventArgs(SmppQuerySm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/QuerySmRespEventArgs.cs b/EventObject/QuerySmRespEventArgs.cs
new file mode 100644
index 0000000..fe211a5
--- /dev/null
+++ b/EventObject/QuerySmRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a query_sm_resp event.
+	/// </summary>
+	public class QuerySmRespEventArgs : SmppEventArgs 
+	{
+		private SmppQuerySmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppQuerySmResp QuerySmRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a QuerySmRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal QuerySmRespEventArgs(SmppQuerySmResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/ReplaceSmEventArgs.cs b/EventObject/ReplaceSmEventArgs.cs
new file mode 100644
index 0000000..70214ef
--- /dev/null
+++ b/EventObject/ReplaceSmEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a replace_sm event.  
+	/// </summary>
+	public class ReplaceSmEventArgs : SmppEventArgs 
+	{
+		private SmppReplaceSm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppReplaceSm ReplaceSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a ReplaceSmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal ReplaceSmEventArgs(SmppReplaceSm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/ReplaceSmRespEventArgs.cs b/EventObject/ReplaceSmRespEventArgs.cs
new file mode 100644
index 0000000..8d6ae42
--- /dev/null
+++ b/EventObject/ReplaceSmRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a replace_sm_resp event.
+	/// </summary>
+	public class ReplaceSmRespEventArgs : SmppEventArgs 
+	{
+		private SmppReplaceSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppReplaceSmResp ReplaceSmRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a ReplaceSmRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal ReplaceSmRespEventArgs(SmppReplaceSmResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/SmppEventArgs.cs b/EventObject/SmppEventArgs.cs
new file mode 100644
index 0000000..2faffef
--- /dev/null
+++ b/EventObject/SmppEventArgs.cs
@@ -0,0 +1,53 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Base class to provide some functionality for all events.
+	/// </summary>
+	public abstract class SmppEventArgs : System.EventArgs 
+	{
+		private Pdu _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public Pdu ResponsePdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the SmppEventArgs.
+		/// </summary>
+		/// <param name="response">The SMPPResponse.</param>
+		public SmppEventArgs(Pdu response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/SubmitMultiEventArgs.cs b/EventObject/SubmitMultiEventArgs.cs
new file mode 100644
index 0000000..c03698d
--- /dev/null
+++ b/EventObject/SubmitMultiEventArgs.cs
@@ -0,0 +1,54 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a submit_multi event.  
+	/// </summary>
+	public class SubmitMultiEventArgs : SmppEventArgs 
+	{
+		private SmppSubmitMulti _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppSubmitMulti SubmitMultiPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a SubmitMultiEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal SubmitMultiEventArgs(SmppSubmitMulti packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/SubmitMultiRespEventArgs.cs b/EventObject/SubmitMultiRespEventArgs.cs
new file mode 100644
index 0000000..846f397
--- /dev/null
+++ b/EventObject/SubmitMultiRespEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a submit_multi_resp event.
+	/// </summary>
+	public class SubmitMultiRespEventArgs : SmppEventArgs 
+	{
+		private SmppSubmitMultiResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppSubmitMultiResp SubmitMultiRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a SubmitMultiRespEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal SubmitMultiRespEventArgs(SmppSubmitMultiResp packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/SubmitSmEventArgs.cs b/EventObject/SubmitSmEventArgs.cs
new file mode 100644
index 0000000..72a856c
--- /dev/null
+++ b/EventObject/SubmitSmEventArgs.cs
@@ -0,0 +1,53 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+
+namespace RoaminSMPP.EventObjects 
+{
+	/// <summary>
+	/// Class that defines a submit_sm event.
+	/// </summary>
+	public class SubmitSmEventArgs : SmppEventArgs 
+	{
+		private SmppSubmitSm _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppSubmitSm SubmitSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a SubmitSmEventArgs.
+		/// </summary>
+		/// <param name="packet">The PDU that was received.</param>
+		internal SubmitSmEventArgs(SmppSubmitSm packet): base(packet)
+		{
+			_response = packet;
+		}
+	}
+}
diff --git a/EventObject/SubmitSmRespEventArgs.cs b/EventObject/SubmitSmRespEventArgs.cs
new file mode 100644
index 0000000..f1c65fb
--- /dev/null
+++ b/EventObject/SubmitSmRespEventArgs.cs
@@ -0,0 +1,53 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines the submit_sm_resp event.
+	/// </summary>
+	public class SubmitSmRespEventArgs : SmppEventArgs 
+	{
+		private SmppSubmitSmResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppSubmitSmResp SubmitSmPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the SubmitSmRespEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppSubmitSmResp.</param>
+		internal SubmitSmRespEventArgs(SmppSubmitSmResp response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
diff --git a/EventObject/UnbindEventArgs.cs b/EventObject/UnbindEventArgs.cs
new file mode 100644
index 0000000..d50ac73
--- /dev/null
+++ b/EventObject/UnbindEventArgs.cs
@@ -0,0 +1,55 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+using System;
+using RoaminSMPP.Packet.Response;
+using RoaminSMPP.Packet.Request;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines the unbind event.
+	/// </summary>
+	public class UnbindEventArgs : SmppEventArgs 
+	{
+		SmppUnbind _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppUnbind UnbindPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the UnbindEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppUnbind.</param>
+		internal UnbindEventArgs(SmppUnbind response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
+
diff --git a/EventObject/UnbindRespEventArgs.cs b/EventObject/UnbindRespEventArgs.cs
new file mode 100644
index 0000000..b0b4672
--- /dev/null
+++ b/EventObject/UnbindRespEventArgs.cs
@@ -0,0 +1,53 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.EventObjects 
+{
+
+	/// <summary>
+	/// Class that defines the unbind_resp event.
+	/// </summary>
+	public class UnbindRespEventArgs : SmppEventArgs 
+	{
+		SmppUnbindResp _response;
+
+		/// <summary>
+		/// Allows access to the underlying Pdu.
+		/// </summary>
+		public SmppUnbindResp UnbindRespPdu
+		{
+			get
+			{
+				return _response;
+			}
+		}
+
+		/// <summary>
+		/// Sets up the UnbindEventArgs.
+		/// </summary>
+		/// <param name="response">The SmppUnbindResp.</param>
+		internal UnbindRespEventArgs(SmppUnbindResp response): base(response)
+		{
+			_response = response;
+		}
+	}
+}
+
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..b860267
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/Packet/Pdu.cs b/Packet/Pdu.cs
new file mode 100644
index 0000000..8f1934e
--- /dev/null
+++ b/Packet/Pdu.cs
@@ -0,0 +1,1399 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Diagnostics;
+using RoaminSMPP.Utility;
+using System.Text;
+
+namespace RoaminSMPP.Packet
+{
+	/// <summary>
+	/// Represents a protocol data unit.  This class holds type enumerations and common 
+	/// functionality for request and response Pdus.
+	/// </summary>
+	public abstract class Pdu : IDisposable
+	{			
+		#region constants
+		
+		/// <summary>
+		/// Standard length of Pdu header.
+		/// </summary>
+		protected const int HEADER_LENGTH = 16;
+		/// <summary>
+		/// Delivery time length
+		/// </summary>
+		protected const int DATE_TIME_LENGTH = 16;
+		
+		#endregion constants
+		
+		#region private fields
+		
+		private static uint _StaticSequenceNumber = 0;
+	  private uint _CommandStatus;
+		private CommandIdType _CommandID;
+		private TlvTable _tlvTable = new TlvTable();
+		private uint _CustomSequenceNumber = 0;
+		private uint _SequenceNumber = 0;
+		
+		private byte[] _PacketBytes = new byte[0];
+		private uint _CommandLength;
+		
+		#endregion private fields
+		
+		#region properties
+		
+		/// <summary>
+		/// Gets or sets the byte response from the SMSC.  This will return a clone of the 
+		/// byte array upon a "get" request. 
+		/// </summary>
+		public byte[] PacketBytes
+		{
+			get
+			{
+				return(byte[])_PacketBytes.Clone();
+			}
+			
+			set
+			{
+				_PacketBytes = value;
+			}
+		}
+		
+		/// <summary>
+		/// Defines the overall length of the Pdu in octets(i.e. bytes).
+		/// </summary>
+		public uint CommandLength
+		{
+			get
+			{
+				return _CommandLength;
+			}
+		}
+		
+		/// <summary>
+		/// The sequence number of the message.  Only call this after you call 
+		/// GetMSBHexEncoding; it will be incorrect otherwise.  If you are setting the 
+		/// sequence number(such as for a deliver_sm_resp), set this before you call 
+		/// GetMSBHexEncoding.  Note that setting the custom sequence number will 
+		/// disable the automatic updating of the sequence number for this instance.  
+		/// You can restore the automatic updating by setting this property to 0.
+		/// </summary>
+		public uint SequenceNumber
+		{
+			get
+			{
+				return _SequenceNumber;
+			}
+			set
+			{
+				_CustomSequenceNumber = value;
+			}
+		}
+		
+		/// <summary>
+		/// Indicates outcome of request.
+		/// </summary>
+		public uint CommandStatus
+		{
+			get
+			{
+				return _CommandStatus;
+			}
+			set
+			{
+				_CommandStatus = value;
+			}
+		}
+		
+		/// <summary>
+		/// The command ID of this Pdu.
+		/// </summary>
+		protected CommandIdType CommandID
+		{
+			get
+			{
+				return _CommandID;
+			}
+			set
+			{
+				_CommandID = value;
+			}
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Constructor for sent Pdus.
+		/// </summary>
+		protected Pdu()
+		{
+			InitPdu();
+		}
+		
+		/// <summary>
+		/// Constructor for received Pdus.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to translate to a Pdu.</param>
+		protected Pdu(byte[] incomingBytes)
+		{
+			#if DEBUG
+			Console.WriteLine("In Pdu byte[] constructor");
+			#endif
+			_PacketBytes = incomingBytes;
+			_CommandLength = DecodeCommandLength(_PacketBytes);
+			_CommandID = DecodeCommandId(_PacketBytes);
+			_CommandStatus = UnsignedNumConverter.SwapByteOrdering(BitConverter.ToUInt32(_PacketBytes, 8));
+			_SequenceNumber = UnsignedNumConverter.SwapByteOrdering(BitConverter.ToUInt32(_PacketBytes, 12));
+			_PacketBytes = TrimResponsePdu(_PacketBytes);
+			
+			//set the other Pdu-specific fields
+			DecodeSmscResponse();
+		}
+		
+		#endregion constructors
+		
+		#region overridable methods
+		
+		/// <summary>
+		/// Initializes this Pdu.  Override to add more functionality, but don't forget to 
+		/// call this one.
+		/// </summary>
+		protected virtual void InitPdu()
+		{
+			CommandStatus = 0;
+			CommandID = Pdu.CommandIdType.generic_nack;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public virtual void ToMsbHexEncoding()
+		{
+			throw new NotImplementedException("GetMSBHexEncoding is not implemented in Pdu.");
+		}
+		
+		/// <summary>
+		/// Decodes the bind response from the SMSC.  This version throws a NotImplementedException.
+		/// </summary>
+		protected virtual void DecodeSmscResponse()
+		{
+			throw new NotImplementedException("DecodeSmscResponse is not implemented in Pdu.");
+		}
+		
+		#endregion overridable methods
+		
+		/// <summary>
+		/// Calculates the length of the given ArrayList representation of the Pdu and
+		/// inserts this length into the appropriate spot in the Pdu.  This will call
+		/// TrimToSize()on the ArrayList-the caller need not do it.
+		/// </summary>
+		/// <param name="pdu">The protocol data unit to calculate the
+		/// length for.</param>
+		/// <returns>The Pdu with the length inserted, trimmed to size.</returns>
+		protected static ArrayList InsertLengthIntoPdu(ArrayList pdu)
+		{
+			pdu.TrimToSize();
+			uint commandLength =(uint)(4 + pdu.Count);
+			uint reqLenH2N = UnsignedNumConverter.SwapByteOrdering(commandLength);
+			byte[] reqLenArray = BitConverter.GetBytes(reqLenH2N);
+			//insert into the Pdu
+			pdu.InsertRange(0, reqLenArray);
+			pdu.TrimToSize();
+			
+			return pdu;
+		}
+		
+		/// <summary>
+		/// Takes the given Pdu, calculates its length(trimming it beforehand), inserting
+		/// its length, and copying it to a byte array.
+		/// </summary>
+		/// <param name="pdu">The Pdu to encode.</param>
+		/// <returns>The byte array representation of the Pdu.</returns>
+		protected byte[] EncodePduForTransmission(ArrayList pdu)
+		{
+			AddTlvBytes(ref pdu);
+			pdu = InsertLengthIntoPdu(pdu);
+			byte[] result = new byte[pdu.Count];
+			pdu.CopyTo(result);
+			
+			return result;
+		}
+		
+		/// <summary>
+		/// Retrieves the given bytes from the TLV table and converts them into a
+		/// host order UInt16.
+		/// </summary>
+		/// <param name="tag">The TLV tag to use for retrieval</param>
+		/// <returns>The host order result.</returns>
+		protected UInt16 GetHostOrderUInt16FromTlv(ushort tag)
+		{
+			return UnsignedNumConverter.SwapByteOrdering(
+				BitConverter.ToUInt16(GetOptionalParamBytes(tag), 0));
+		}
+		
+		/// <summary>
+		/// Retrieves the given bytes from the TLV table and converts them into a
+		/// host order UInt32.
+		/// </summary>
+		/// <param name="tag">The TLV tag to use for retrieval</param>
+		/// <returns>The host order result.</returns>
+		protected UInt32 GetHostOrderUInt32FromTlv(ushort tag)
+		{
+			return UnsignedNumConverter.SwapByteOrdering(
+				BitConverter.ToUInt32(GetOptionalParamBytes(tag), 0));
+		}
+		
+		/// <summary>
+		/// Takes the given value and puts it into the TLV table, accounting for 
+		/// network byte ordering.
+		/// </summary>
+		/// <param name="tag">The TLV tag to use for retrieval</param>
+		/// <param name="val">The value to put into the table</param>
+		protected void SetHostOrderValueIntoTlv(UInt16 tag, UInt16 val)
+		{
+			SetOptionalParamBytes(
+						tag,
+						BitConverter.GetBytes(
+						UnsignedNumConverter.SwapByteOrdering(val)));
+		}
+		
+		/// <summary>
+		/// Takes the given value and puts it into the TLV table, accounting for 
+		/// network byte ordering.
+		/// </summary>
+		/// <param name="tag">The TLV tag to use for retrieval</param>
+		/// <param name="val">The value to put into the table</param>
+		protected void SetHostOrderValueIntoTlv(UInt16 tag, UInt32 val)
+		{
+			SetOptionalParamBytes(
+						tag,
+						BitConverter.GetBytes(
+						UnsignedNumConverter.SwapByteOrdering(val)));
+		}
+		
+		/// <summary>
+		/// What remains after the header is stripped off the Pdu.  Subclasses
+		/// don't need the header as its information is stored here.  In
+		/// addition, this allows them to manipulate the response data
+		/// all they want without destroying the original.  The copying is
+		/// done every time this property is accessed, so use caution in a
+		/// high-performance setting.
+		/// </summary>
+		protected byte[] BytesAfterHeader
+		{
+			get
+			{
+				long length = _PacketBytes.Length - HEADER_LENGTH;
+				byte[] remainder = new byte[length];
+				Array.Copy(_PacketBytes, HEADER_LENGTH, remainder, 0, length);
+				return remainder;
+			}
+		}
+		
+		/// <summary>
+		/// Creates an ArrayList consisting of the Pdu header.  Command ID and status
+		/// need to be set before calling this.
+		/// </summary>
+		/// <returns>The Pdu as a trimmed ArrayList.</returns>
+		protected ArrayList GetPduHeader()
+		{
+			ArrayList pdu = new ArrayList();
+			pdu.AddRange(BitConverter.GetBytes(UnsignedNumConverter.SwapByteOrdering((uint)_CommandID)));
+			pdu.AddRange(BitConverter.GetBytes(UnsignedNumConverter.SwapByteOrdering(_CommandStatus)));
+			
+			//increase the sequence number
+			GenerateSequenceNumber();			
+			pdu.AddRange(BitConverter.GetBytes(UnsignedNumConverter.SwapByteOrdering(_SequenceNumber)));
+			pdu.TrimToSize();
+			return pdu;
+		}
+		
+		/// <summary>
+		/// Generates a monotonically increasing sequence number for each Pdu.  When it
+		/// hits the the 32 bit unsigned int maximum, it starts over.
+		/// </summary>
+		private void GenerateSequenceNumber()
+		{
+			if(_CustomSequenceNumber == 0)
+			{
+				_StaticSequenceNumber++;
+				if(_StaticSequenceNumber >= UInt32.MaxValue)
+				{
+					_StaticSequenceNumber = 1;
+				}
+				_SequenceNumber = _StaticSequenceNumber;
+			}
+			else
+			{
+				_SequenceNumber = _CustomSequenceNumber;
+			}
+		}
+		
+		#region TLV table methods
+		
+		/// <summary>
+		/// Gets the optional parameter string associated with
+		/// the given tag.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <returns>The optional parameter string, the empty
+		/// string if not found.</returns>
+		public string GetOptionalParamString(UInt16 tag)
+		{
+			return _tlvTable.GetOptionalParamString(UnsignedNumConverter.SwapByteOrdering(tag));
+		}
+		
+		/// <summary>
+		/// Gets the optional parameter bytes associated with
+		/// the given tag.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <returns>The optional parameter bytes, null if
+		/// not found.</returns>
+		public byte[] GetOptionalParamBytes(UInt16 tag)
+		{
+			return _tlvTable.GetOptionalParamBytes(UnsignedNumConverter.SwapByteOrdering(tag));
+		}
+		
+		/// <summary>
+		/// Sets the given TLV(as a string)into the table.  This ignores
+		/// null values.  This will reverse the byte order in the tag for you 
+		///(necessary for encoding).
+		/// </summary>
+		/// <param name="tag">The tag for this TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void SetOptionalParamString(UInt16 tag, string val)
+		{
+			_tlvTable.SetOptionalParamString(UnsignedNumConverter.SwapByteOrdering(tag), val);
+		}
+		
+		/// <summary>
+		/// Sets the given TLV(as a byte array)into the table.  This will not take
+		/// care of big-endian/little-endian issues, although it will reverse the byte order 
+		/// in the tag for you(necessary for encoding).  This ignores null values.
+		/// </summary>
+		/// <param name="tag">The tag for this TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void SetOptionalParamBytes(UInt16 tag, byte[] val)
+		{
+			_tlvTable.SetOptionalParamBytes(UnsignedNumConverter.SwapByteOrdering(tag), val);
+		}
+		
+		/// <summary>
+		/// Allows the updating of TLV values.  This will not take care of 
+		/// big-endian/little-endian issues, although it will reverse the byte order 
+		/// in the tag for you(necessary for encoding).
+		/// </summary>
+		/// <param name="tag">The tag for this TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void UpdateOptionalParamBytes(UInt16 tag, byte[] val)
+		{
+			_tlvTable.UpdateOptionalParamBytes(UnsignedNumConverter.SwapByteOrdering(tag), val);
+		}
+		
+		/// <summary>
+		/// Allows the updating of TLV values.  This will reverse the byte order in the tag for you 
+		///(necessary for encoding).
+		/// </summary>
+		/// <param name="tag">The tag for this TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void UpdateOptionalParamString(UInt16 tag, string val)
+		{
+			_tlvTable.UpdateOptionalParamString(UnsignedNumConverter.SwapByteOrdering(tag), val);
+		}
+		
+		/// <summary>
+		/// Takes the given bytes and attempts to insert them into the TLV table.
+		/// </summary>
+		/// <param name="tlvBytes">The bytes to convert for the TLVs.</param>
+		protected void TranslateTlvDataIntoTable(byte[] tlvBytes)
+		{
+			_tlvTable.TranslateTlvDataIntoTable(tlvBytes);
+		}
+		
+		/// <summary>
+		/// Takes the given bytes and attempts to insert them into the TLV table.
+		/// </summary>
+		/// <param name="tlvBytes">The bytes to convert for the TLVs.</param>
+		/// <param name="index">The index of the byte array to start at.  This is here
+		/// because in some instances you may not want to start at the
+		/// beginning.</param>
+		protected void TranslateTlvDataIntoTable(byte[] tlvBytes, Int32 index)
+		{
+			#if DEBUG
+			Console.WriteLine("Calling TranslateTlvDataIntoTable(byte[], Int32)");
+			#endif
+			_tlvTable.TranslateTlvDataIntoTable(tlvBytes, index);
+		}
+		
+		/// <summary>
+		/// Adds the TLV bytes to the given Pdu.
+		/// </summary>
+		/// <param name="pdu">The Pdu to add to.</param>
+		protected void AddTlvBytes(ref ArrayList pdu)
+		{
+			ArrayList tlvs = _tlvTable.GenerateByteEncodedTlv();
+			foreach(byte[] tlv in tlvs)
+			{
+				#if DEBUG
+				StringBuilder sb = new StringBuilder("\nAdding TLV bytes\n");
+				for(int i = 0; i < tlv.Length; i++) 
+				{
+					sb.Append(tlv[i].ToString("X").PadLeft(2, '0'));
+					sb.Append(" ");
+				}
+				sb.Append("\n");
+				Console.WriteLine(sb);
+				
+				#endif
+				
+				pdu.AddRange(tlv);
+			}
+		}
+		
+		#endregion TLV table methods
+		
+		#region enumerations
+		
+		/// <summary>
+		/// Enumerates the bearer types for source and destination.
+		/// </summary>
+		public enum BearerType : byte
+		{
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 0x00,
+			/// <summary>
+			/// SMS
+			/// </summary>
+			SMS = 0x01,
+			/// <summary>
+			/// CircuitSwitchedData
+			/// </summary>
+			CircuitSwitchedData = 0x02,
+			/// <summary>
+			/// PacketData
+			/// </summary>
+			PacketData = 0x03,
+			/// <summary>
+			/// USSD
+			/// </summary>
+			USSD = 0x04,
+			/// <summary>
+			/// CDPD
+			/// </summary>
+			CDPD = 0x05,
+			/// <summary>
+			/// DataTAC
+			/// </summary>
+			DataTAC = 0x06,
+			/// <summary>
+			/// FLEX_ReFLEX
+			/// </summary>
+			FLEX_ReFLEX = 0x07,
+			/// <summary>
+			/// CellBroadcast
+			/// </summary>
+			CellBroadcast = 0x08
+		}
+		
+		/// <summary>
+		/// Enumerates the network types for the source and destination.
+		/// </summary>
+		public enum NetworkType : byte
+		{
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 0x00,
+			/// <summary>
+			/// GSM
+			/// </summary>
+			GSM = 0x01,
+			/// <summary>
+			/// ANSI_136_TDMA
+			/// </summary>
+			ANSI_136_TDMA = 0x02,
+			/// <summary>
+			/// IS_95_CDMA
+			/// </summary>
+			IS_95_CDMA = 0x03,
+			/// <summary>
+			/// PDC
+			/// </summary>
+			PDC = 0x04,
+			/// <summary>
+			/// PHS
+			/// </summary>
+			PHS = 0x05,
+			/// <summary>
+			/// iDEN
+			/// </summary>
+			iDEN = 0x06,
+			/// <summary>
+			/// AMPS
+			/// </summary>
+			AMPS = 0x07,
+			/// <summary>
+			/// PagingNetwork
+			/// </summary>
+			PagingNetwork = 0x08
+		}
+		
+		/// <summary>
+		/// Enumerates the different states a message can be in.
+		/// </summary>
+		public enum MessageStateType : byte
+		{
+			/// <summary>
+			/// Enroute
+			/// </summary>
+			Enroute = 1,
+			/// <summary>
+			/// Delivered
+			/// </summary>
+			Delivered = 2,
+			/// <summary>
+			/// Expired
+			/// </summary>
+			Expired = 3,
+			/// <summary>
+			/// Deleted
+			/// </summary>
+			Deleted = 4,
+			/// <summary>
+			/// Undeliverable
+			/// </summary>
+			Undeliverable = 5,
+			/// <summary>
+			/// Accepted
+			/// </summary>
+			Accepted = 6,
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 7,
+			/// <summary>
+			/// Rejected
+			/// </summary>
+			Rejected = 8
+		}
+		
+		/// <summary>
+		/// SMPP version type.
+		/// </summary>
+		public enum SmppVersionType : byte
+		{
+			/// <summary>
+			/// Version 3.3 of the SMPP spec.
+			/// </summary>
+			Version3_3 = 0x33,
+			/// <summary>
+			/// Version 3.4 of the SMPP spec.
+			/// </summary>
+			Version3_4 = 0x34
+		}
+		
+		/// <summary>
+		/// Enumerates the source address subunit types.
+		/// </summary>
+		public enum AddressSubunitType : byte
+		{
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 0x00,
+			/// <summary>
+			/// MSDisplay
+			/// </summary>
+			MSDisplay = 0x01,
+			/// <summary>
+			/// MobileEquipment
+			/// </summary>
+			MobileEquipment = 0x02,
+			/// <summary>
+			/// SmartCard1
+			/// </summary>
+			SmartCard1 = 0x03,
+			/// <summary>
+			/// ExternalUnit1
+			/// </summary>
+			ExternalUnit1 = 0x04
+		}
+		
+		/// <summary>
+		/// Enumerates the display time type.
+		/// </summary>
+		public enum DisplayTimeType : byte
+		{
+			/// <summary>
+			/// Temporary
+			/// </summary>
+			Temporary = 0x00,
+			/// <summary>
+			/// Default
+			/// </summary>
+			Default = 0x01,
+			/// <summary>
+			/// Invoke
+			/// </summary>
+			Invoke = 0x02
+		}
+		
+		/// <summary>
+		/// Enumerates the type of the ITS Reply Type
+		/// </summary>
+		public enum ItsReplyTypeType : byte
+		{
+			/// <summary>
+			/// Digit
+			/// </summary>
+			Digit = 0,
+			/// <summary>
+			/// Number
+			/// </summary>
+			Number = 1,
+			/// <summary>
+			/// TelephoneNum
+			/// </summary>
+			TelephoneNum = 2,
+			/// <summary>
+			/// Password
+			/// </summary>
+			Password = 3,
+			/// <summary>
+			/// CharacterLine
+			/// </summary>
+			CharacterLine = 4,
+			/// <summary>
+			/// Menu
+			/// </summary>
+			Menu = 5,
+			/// <summary>
+			/// Date
+			/// </summary>
+			Date = 6,
+			/// <summary>
+			/// Time
+			/// </summary>
+			Time = 7,
+			/// <summary>
+			/// Continue
+			/// </summary>
+			Continue = 8
+		}
+		
+		/// <summary>
+		/// Enumerates the MS Display type.
+		/// </summary>
+		public enum MsValidityType : byte
+		{
+			/// <summary>
+			/// StoreIndefinitely
+			/// </summary>
+			StoreIndefinitely = 0x00,
+			/// <summary>
+			/// PowerDown
+			/// </summary>
+			PowerDown = 0x01,
+			/// <summary>
+			/// SIDBased
+			/// </summary>
+			SIDBased = 0x02,
+			/// <summary>
+			/// DisplayOnly
+			/// </summary>
+			DisplayOnly = 0x03
+		}
+		
+		/// <summary>
+		/// Enumerates all of the "standard" optional codes.  This is more for
+		/// convenience when writing/updating this library than for end programmers,
+		/// as the the TLV table methods take a ushort/UInt16 rather than an
+		/// OptionalParamCodes enumeration.
+		/// </summary>
+		public enum OptionalParamCodes : ushort
+		{
+			/// <summary>
+			/// Destination address subunit
+			/// </summary>
+			dest_addr_subunit = 0x0005,
+			/// <summary>
+			/// Destination address network type
+			/// </summary>
+			dest_network_type = 0x0006,
+			/// <summary>
+			/// Destination address bearer type
+			/// </summary>
+			dest_bearer_type = 0x0007,
+			/// <summary>
+			/// Destination address telematics ID
+			/// </summary>
+			dest_telematics_id = 0x0008,
+			/// <summary>
+			/// Source address subunit
+			/// </summary>
+			source_addr_subunit = 0x000D,
+			/// <summary>
+			/// Source address network type
+			/// </summary>
+			source_network_type = 0x000E,
+			/// <summary>
+			/// Source address bearer type
+			/// </summary>
+			source_bearer_type = 0x000F,
+			/// <summary>
+			/// Source address telematics ID
+			/// </summary>
+			source_telematics_id = 0x0010,
+			/// <summary>
+			/// Quality of service time to live
+			/// </summary>
+			qos_time_to_live = 0x0017,
+			/// <summary>
+			/// Payload type
+			/// </summary>
+			payload_type = 0x0019,
+			/// <summary>
+			/// Additional status info
+			/// </summary>
+			additional_status_info_text = 0x001D,
+			/// <summary>
+			/// Receipted message ID
+			/// </summary>
+			receipted_message_id = 0x001E,
+			/// <summary>
+			/// Message wait facilities
+			/// </summary>
+			ms_msg_wait_facilities = 0x0030,
+			/// <summary>
+			/// Privacy indicator
+			/// </summary>
+			privacy_indicator = 0x0201,
+			/// <summary>
+			/// Source subaddress
+			/// </summary>
+			source_subaddress = 0x0202,
+			/// <summary>
+			/// Destination subaddress
+			/// </summary>
+			dest_subaddress = 0x0203,
+			/// <summary>
+			/// User message reference
+			/// </summary>
+			user_message_reference = 0x0204,
+			/// <summary>
+			/// User response code
+			/// </summary>
+			user_response_code = 0x0205,
+			/// <summary>
+			/// Source port
+			/// </summary>
+			source_port = 0x020A,
+			/// <summary>
+			/// Destination port
+			/// </summary>
+			destination_port = 0x020B,
+			/// <summary>
+			/// Message reference number
+			/// </summary>
+			sar_msg_ref_num = 0x020C,
+			/// <summary>
+			/// Language indicator
+			/// </summary>
+			language_indicator = 0x020D,
+			/// <summary>
+			/// Total segments
+			/// </summary>
+			sar_total_segments = 0x020E,
+			/// <summary>
+			/// Segment sequence number
+			/// </summary>
+			sar_segment_seqnum = 0x020F,
+			/// <summary>
+			/// Interface version
+			/// </summary>
+			SC_interface_version = 0x0210,
+			/// <summary>
+			/// Callback number indicator
+			/// </summary>
+			callback_num_pres_ind = 0x0302,
+			/// <summary>
+			/// Callback number tag
+			/// </summary>
+			callback_num_atag = 0x0303,
+			/// <summary>
+			/// Total number of messages
+			/// </summary>
+			number_of_messages = 0x0304,
+			/// <summary>
+			/// Callback number
+			/// </summary>
+			callback_num = 0x0381,
+			/// <summary>
+			/// DPF result
+			/// </summary>
+			dpf_result = 0x0420,
+			/// <summary>
+			/// Set DPF
+			/// </summary>
+			set_dpf = 0x0421,
+			/// <summary>
+			/// Availability status
+			/// </summary>
+			ms_availability_status = 0x0422,
+			/// <summary>
+			/// Network error code
+			/// </summary>
+			network_error_code = 0x0423,
+			/// <summary>
+			/// Message payload
+			/// </summary>
+			message_payload = 0x0424,
+			/// <summary>
+			/// Reason for delivery failure
+			/// </summary>
+			delivery_failure_reason = 0x0425,
+			/// <summary>
+			/// More messages to send flag
+			/// </summary>
+			more_messages_to_send = 0x0426,
+			/// <summary>
+			/// Message state
+			/// </summary>
+			message_state = 0x0427,
+			/// <summary>
+			/// USSD service opcode
+			/// </summary>
+			ussd_service_op = 0x0501,
+			/// <summary>
+			/// Display time
+			/// </summary>
+			display_time = 0x1201,
+			/// <summary>
+			/// SMS signal
+			/// </summary>
+			sms_signal = 0x1203,
+			/// <summary>
+			/// Message validity
+			/// </summary>
+			ms_validity = 0x1204,
+			/// <summary>
+			/// Alert on message delivery
+			/// </summary>
+			alert_on_message_delivery = 0x130C,
+			/// <summary>
+			/// ITS reply type
+			/// </summary>
+			its_reply_type = 0x1380,
+			/// <summary>
+			/// ITS session info
+			/// </summary>
+			its_session_info = 0x1383
+		}
+		
+		/// <summary>
+		/// Enumerates the type of number types that can be used for the SMSC 
+		/// message
+		/// sending.
+		/// </summary>
+		public enum TonType : byte
+		{
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 0x00,
+			/// <summary>
+			/// International
+			/// </summary>
+			International = 0x01,
+			/// <summary>
+			/// National
+			/// </summary>
+			National = 0x02,
+			/// <summary>
+			/// Network specific
+			/// </summary>
+			NetworkSpecific = 0x03,
+			/// <summary>
+			/// Subscriber number
+			/// </summary>
+			SubscriberNumber = 0x04,
+			/// <summary>
+			/// Alphanumeric
+			/// </summary>
+			Alphanumeric = 0x05,
+			/// <summary>
+			/// Abbreviated
+			/// </summary>
+			Abbreviated = 0x06
+		}
+		
+		/// <summary>
+		/// Enumerates the number plan indicator types that can be used for the 
+		/// SMSC
+		/// message sending.
+		/// </summary>
+		public enum NpiType : byte
+		{
+			/// <summary>
+			/// Unknown
+			/// </summary>
+			Unknown = 0x00,
+			/// <summary>
+			/// ISDN
+			/// </summary>
+			ISDN = 0x01,
+			/// <summary>
+			/// Data
+			/// </summary>
+			Data = 0x03,
+			/// <summary>
+			/// Telex
+			/// </summary>
+			Telex = 0x04,
+			/// <summary>
+			/// Land mobile
+			/// </summary>
+			LandMobile = 0x06,
+			/// <summary>
+			/// National
+			/// </summary>
+			National = 0x08,
+			/// <summary>
+			/// Private
+			/// </summary>
+			Private = 0x09,
+			/// <summary>
+			/// ERMES
+			/// </summary>
+			ERMES = 0x0A,
+			/// <summary>
+			/// Internet
+			/// </summary>
+			Internet = 0x0E
+		}
+		
+		/// <summary>
+		/// Enumerates the priority level of the message.
+		/// </summary>
+		public enum PriorityType : byte
+		{
+			/// <summary>
+			/// Lowest
+			/// </summary>
+			Lowest = 0x00,
+			/// <summary>
+			/// Level1
+			/// </summary>
+			Level1 = 0x01,
+			/// <summary>
+			/// Level2
+			/// </summary>
+			Level2 = 0x02,
+			/// <summary>
+			/// Highest
+			/// </summary>
+			Highest = 0x03
+		}
+		
+		/// <summary>
+		/// Enumerates the types of registered delivery.  Not all possible options 
+		/// are present, just the common ones.
+		/// </summary>
+		public enum RegisteredDeliveryType : byte
+		{
+			/// <summary>
+			/// No registered delivery
+			/// </summary>
+			None = 0x00,
+			/// <summary>
+			/// Notification on success or failure
+			/// </summary>
+			OnSuccessOrFailure = 0x01,
+			/// <summary>
+			/// Notification on failure only
+			/// </summary>
+			OnFailure = 0x02
+		}
+		
+		/// <summary>
+		/// Enumerates the data coding types.
+		/// </summary>
+		public enum DataCodingType : byte
+		{
+			/// <summary>
+			/// SMSCDefault
+			/// </summary>
+			SMSCDefault = 0x00,
+			/// <summary>
+			/// IA5_ASCII
+			/// </summary>
+			IA5_ASCII = 0x01,
+			/// <summary>
+			/// OctetUnspecifiedB
+			/// </summary>
+			OctetUnspecifiedB = 0x02,
+			/// <summary>
+			/// Latin1
+			/// </summary>
+			Latin1 = 0x03,
+			/// <summary>
+			/// OctetUnspecifiedA
+			/// </summary>
+			OctetUnspecifiedA = 0x04,
+			/// <summary>
+			/// JIS
+			/// </summary>
+			JIS = 0x05,
+			/// <summary>
+			/// Cyrillic
+			/// </summary>
+			Cyrillic = 0x06,
+			/// <summary>
+			/// Latin_Hebrew
+			/// </summary>
+			Latin_Hebrew = 0x07,
+			/// <summary>
+			/// Pictogram
+			/// </summary>
+			Pictogram = 0x09,
+			/// <summary>
+			/// MusicCodes
+			/// </summary>
+			MusicCodes = 0x0A,
+			/// <summary>
+			/// ExtendedKanjiJIS
+			/// </summary>
+			ExtendedKanjiJIS = 0x0D,
+			/// <summary>
+			/// KS_C
+			/// </summary>
+			KS_C = 0x0E
+		}
+		
+		/// <summary>
+		/// Enumerates the privacy indicator types.
+		/// </summary>
+		public enum PrivacyType : byte
+		{
+			/// <summary>
+			/// Nonrestricted
+			/// </summary>
+			Nonrestricted = 0x00,
+			/// <summary>
+			/// Restricted
+			/// </summary>
+			Restricted = 0x01,
+			/// <summary>
+			/// Confidential
+			/// </summary>
+			Confidential = 0x03,
+			/// <summary>
+			/// Secret
+			/// </summary>
+			Secret = 0x03
+		}
+		
+		/// <summary>
+		/// Enumerates the types of payload type.
+		/// </summary>
+		public enum PayloadTypeType : byte
+		{
+			/// <summary>
+			/// WDPMessage
+			/// </summary>
+			WDPMessage = 0x00,
+			/// <summary>
+			/// WCMPMessage
+			/// </summary>
+			WCMPMessage = 0x01
+		}
+		
+		/// <summary>
+		/// Enumerates the language types.
+		/// </summary>
+		public enum LanguageType : byte
+		{
+			/// <summary>
+			/// Unspecified
+			/// </summary>
+			Unspecified = 0x00,
+			/// <summary>
+			/// English
+			/// </summary>
+			English = 0x01,
+			/// <summary>
+			/// French
+			/// </summary>
+			French = 0x02,
+			/// <summary>
+			/// Spanish
+			/// </summary>
+			Spanish = 0x03,
+			/// <summary>
+			/// German
+			/// </summary>
+			German = 0x04,
+			/// <summary>
+			/// Portuguese
+			/// </summary>
+			Portuguese = 0x05
+		}
+		
+		/// <summary>
+		/// Enumerates the DPF result types.
+		/// </summary>
+		public enum DpfResultType : byte
+		{
+			/// <summary>
+			/// DPFNotSet
+			/// </summary>
+			DPFNotSet = 0,
+			/// <summary>
+			/// DPFSet
+			/// </summary>
+			DPFSet = 1
+		}
+		
+		/// <summary>
+		/// Enumeration of all the Pdu command types.
+		/// </summary>
+		public enum CommandIdType : uint
+		{
+			/// <summary>
+			/// generic_nack
+			/// </summary>
+			generic_nack = 0x80000000,
+			/// <summary>
+			/// bind_receiver
+			/// </summary>
+			bind_receiver = 0x00000001,
+			/// <summary>
+			/// bind_receiver_resp
+			/// </summary>
+			bind_receiver_resp = 0x80000001,
+			/// <summary>
+			/// bind_transmitter
+			/// </summary>
+			bind_transmitter = 0x00000002,
+			/// <summary>
+			/// bind_transmitter_resp
+			/// </summary>
+			bind_transmitter_resp = 0x80000002,
+			/// <summary>
+			/// query_sm
+			/// </summary>
+			query_sm = 0x00000003,
+			/// <summary>
+			/// query_sm_resp
+			/// </summary>
+			query_sm_resp = 0x80000003,
+			/// <summary>
+			/// submit_sm
+			/// </summary>
+			submit_sm = 0x00000004,
+			/// <summary>
+			/// submit_sm_resp
+			/// </summary>
+			submit_sm_resp = 0x80000004,
+			/// <summary>
+			/// deliver_sm
+			/// </summary>
+			deliver_sm = 0x00000005,
+			/// <summary>
+			/// deliver_sm_resp
+			/// </summary>
+			deliver_sm_resp = 0x80000005,
+			/// <summary>
+			/// unbind
+			/// </summary>
+			unbind = 0x00000006,
+			/// <summary>
+			/// unbind_resp
+			/// </summary>
+			unbind_resp = 0x80000006,
+			/// <summary>
+			/// replace_sm
+			/// </summary>
+			replace_sm = 0x00000007,
+			/// <summary>
+			/// replace_sm_resp
+			/// </summary>
+			replace_sm_resp = 0x80000007,
+			/// <summary>
+			/// cancel_sm
+			/// </summary>
+			cancel_sm = 0x00000008,
+			/// <summary>
+			/// cancel_sm_resp
+			/// </summary>
+			cancel_sm_resp = 0x80000008,
+			/// <summary>
+			/// bind_transceiver
+			/// </summary>
+			bind_transceiver = 0x00000009,
+			/// <summary>
+			/// bind_transceiver_resp
+			/// </summary>
+			bind_transceiver_resp = 0x80000009,
+			/// <summary>
+			/// outbind
+			/// </summary>
+			outbind = 0x0000000B,
+			/// <summary>
+			/// enquire_link
+			/// </summary>
+			enquire_link = 0x00000015,
+			/// <summary>
+			/// enquire_link_resp
+			/// </summary>
+			enquire_link_resp = 0x80000015,
+			/// <summary>
+			/// submit_multi
+			/// </summary>
+			submit_multi = 0x00000021,
+			/// <summary>
+			/// submit_multi_resp
+			/// </summary>
+			submit_multi_resp = 0x80000021,
+			/// <summary>
+			/// alert_notification
+			/// </summary>
+			alert_notification = 0x00000102,
+			/// <summary>
+			/// data_sm
+			/// </summary>
+			data_sm = 0x00000103,
+			/// <summary>
+			/// data_sm_resp
+			/// </summary>
+			data_sm_resp = 0x80000103
+		}
+		
+		#endregion enumerations
+		
+		#region utility methods
+		
+		/// <summary>
+		/// Trims the trailing zeroes off of the response Pdu.  Useful for
+		/// tracing and other purposes.  This uses the command length to
+		/// actually trim it down, so TLVs and strings are not lost.  If the
+		/// response actually is the same length as the command length, this
+		/// method performs a pass-through.
+		/// </summary>
+		/// <returns>The trimmed Pdu(byte array).</returns>
+		public static byte[] TrimResponsePdu(byte[] response)
+		{
+			uint commLength = DecodeCommandLength(response);
+			if(commLength == response.Length)
+			{
+				return response;
+			}
+			//trap any weird data coming in
+			if(commLength >= Int32.MaxValue || commLength > response.Length)
+			{
+				return new Byte[0];
+			}
+			
+			byte[] trimmed = new Byte[commLength];
+			for(int i = 0; i < trimmed.Length; i++)
+			{
+				trimmed[i] = response[i];
+			}
+			
+			return trimmed;
+		}
+		
+		/// <summary>
+		/// Utility method to allow the Pdu factory to decode the command
+		/// ID without knowing about packet structure.  Some SMSCs combine
+		/// response packets(even though they shouldn't).
+		/// </summary>
+		/// <param name="response">The Pdu response packet.</param>
+		/// <returns>The ID of the Pdu command(e.g. cancel_sm_resp).</returns>
+		public static CommandIdType DecodeCommandId(byte[] response)
+		{
+			uint id = 0;
+			try
+			{
+				id = UnsignedNumConverter.SwapByteOrdering(BitConverter.ToUInt32(response, 4));
+				return(CommandIdType)id;
+			}
+			catch		//possible that we are reading a bad command
+			{
+				return CommandIdType.generic_nack;
+			}
+		}
+		
+		/// <summary>
+		/// Utility method to allow the Pdu factory to decode the command
+		/// length without knowing about packet structure.  Some SMSCs combine
+		/// response packets(even though they shouldn't).
+		/// </summary>
+		/// <param name="response">The Pdu response packet.</param>
+		/// <returns>The length of the Pdu command.</returns>
+		public static UInt32 DecodeCommandLength(byte[] response)
+		{
+			return UnsignedNumConverter.SwapByteOrdering(BitConverter.ToUInt32(response, 0));
+		}
+		
+		#endregion utility methods
+		
+		#region IDisposable methods
+		
+		/// <summary>
+		/// Implementation of IDisposable
+		/// </summary>
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this); 
+		}
+	
+		/// <summary>
+		/// Method for derived classes to implement.
+		/// </summary>
+		/// <param name="disposing">Set to false if called from a finalizer.</param>
+		protected virtual void Dispose(bool disposing)
+		{
+			if(disposing)
+			{
+				// Free other state(managed objects).
+			}
+			// Free your own state(unmanaged objects).
+			// Set large fields to null.
+		}
+	
+		/// <summary>
+		/// Finalizer.  Base classes will inherit this-used when Dispose()is not automatically called.
+		/// </summary>
+		~Pdu()
+		{
+			// Simply call Dispose(false).
+			Dispose(false);
+		}
+		
+		#endregion IDisposable methods
+	}
+}
diff --git a/Packet/Request/MessageLcd2.cs b/Packet/Request/MessageLcd2.cs
new file mode 100644
index 0000000..6054d1b
--- /dev/null
+++ b/Packet/Request/MessageLcd2.cs
@@ -0,0 +1,267 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// This class encapsulates common attributes for submit_sm and submit_multi Pdus.
+	/// </summary>
+	public abstract class MessageLcd2 : MessageLcd3
+	{
+		/// <summary>
+		/// Limit of short message.
+		/// </summary>
+		public const int SHORT_MESSAGE_LIMIT = 160;
+		
+		#region private fields
+		
+		private SmppVersionType _ProtocolId = Pdu.SmppVersionType.Version3_4;
+		private PriorityType _PriorityFlag = Pdu.PriorityType.Level1;
+		private string _ScheduleDeliveryTime = string.Empty;
+		private string _ValidityPeriod = string.Empty;
+		private bool _ReplaceIfPresentFlag = false;
+		private byte _SmDefaultMessageId = 0;
+		private object _ShortMessage = null;
+		
+		#endregion private fields
+		
+		#region protected fields
+		
+		/// <summary>
+		/// The length of the short message.
+		/// </summary>
+		protected byte _SmLength = 0;
+		
+		#endregion protected fields
+		
+		#region properties
+		
+		/// <summary>
+		/// Protocol Identifier; network specific field.
+		/// </summary>
+		public SmppVersionType ProtocolId
+		{
+			get
+			{
+				return _ProtocolId;
+			}
+			set
+			{
+				_ProtocolId = value;
+			}
+		}
+		
+		/// <summary>
+		/// The priority level of the message.
+		/// </summary>
+		public PriorityType PriorityFlag
+		{
+			get
+			{
+				return _PriorityFlag;
+			}
+			set
+			{
+				_PriorityFlag = value;
+			}
+		}
+		
+		/// <summary>
+		/// Scheduled delivery time for the message delivery.  Set to null for immediate 
+		/// delivery.  Otherwise, use YYMMDDhhmmsstnn as the format.  See section 7.1.1 of 
+		/// the SMPP spec for more details.
+		/// </summary>
+		public string ScheduleDeliveryTime
+		{
+			get
+			{
+				return _ScheduleDeliveryTime;
+			}
+			set
+			{
+				if(value != null && value != string.Empty)
+				{
+					if(value.Length == DATE_TIME_LENGTH)
+					{
+						_ScheduleDeliveryTime = value;
+					}
+					else
+					{
+						throw new ArgumentException("Scheduled delivery time not in correct format.");
+					}
+				}
+				else
+				{
+					_ScheduleDeliveryTime = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The validity period of this message.  Set to null to request the SMSC default 
+		/// validity period.  Otherwise, use YYMMDDhhmmsstnn as the format.  See section 7.1.1 of 
+		/// the SMPP spec for more details.
+		/// </summary>
+		public string ValidityPeriod
+		{
+			get
+			{
+				return _ValidityPeriod;
+			}
+			set
+			{
+				if(value != null && value != string.Empty)
+				{
+					if(value.Length == DATE_TIME_LENGTH)
+					{
+						_ValidityPeriod = value;
+					}
+					else
+					{
+						throw new ArgumentException("Validity period not in correct format.");
+					}
+				}
+				else
+				{
+					_ValidityPeriod = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Flag indicating if submitted message should replace an existing message.
+		/// </summary>
+		public bool ReplaceIfPresentFlag
+		{
+			get
+			{
+				return _ReplaceIfPresentFlag;
+			}
+			set
+			{
+				_ReplaceIfPresentFlag = value;
+			}
+		}
+		
+		/// <summary>
+		/// Allows use of a canned message from the SMSC.  If not using an SMSC canned message, 
+		/// set to 0.
+		/// </summary>
+		public byte SmDefaultMessageId
+		{
+			get
+			{
+				return _SmDefaultMessageId;
+			}
+			set
+			{
+				_SmDefaultMessageId = value;
+			}
+		}
+		
+		/// <summary>
+		/// The short message to send, up to 160 octets.  If you need more length, use the 
+		/// MessagePayload property.  Do not use both at the same time!  Setting this to null 
+		/// will result in an empty string.  This can be either a string or a byte array; anything 
+		/// else will result in an exception.
+		/// </summary>
+		public object ShortMessage
+		{
+			get
+			{
+				return _ShortMessage;
+			}
+			set
+			{
+				_ShortMessage = value;
+			}
+		}
+		
+		/// <summary>
+		/// The length of the short message.
+		/// </summary>
+		public byte SmLength
+		{
+			get
+			{
+				return _SmLength;
+			}
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Groups construction tasks for subclasses.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none, 
+		/// ESM class to 0, data coding to SMSC default, protocol ID to v3.4, priority to level 1,
+		/// validity period to default, replace if present to false, default message ID to 0, 
+		/// and the short message to an empty string.
+		/// </summary>
+		protected MessageLcd2(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new MessageLcd2 for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		protected MessageLcd2(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Creates the bytes after the destination address bytes.  This also inserts the TLV
+		/// table data.  Common to both submit and submit multiple.
+		/// </summary>
+		/// <returns>The bytes in the Pdu before the destination address(es).</returns>
+		protected ArrayList GetBytesAfterDestination()
+		{
+			ArrayList pdu = new ArrayList();
+			pdu.Add(EsmClass);
+			pdu.Add((byte)ProtocolId);
+			pdu.Add((byte)PriorityFlag);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ScheduleDeliveryTime)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ValidityPeriod)));
+			pdu.Add((byte)RegisteredDelivery);
+			
+			if(ReplaceIfPresentFlag == true)
+			{
+				pdu.Add((byte)0x01);
+			}
+			else
+			{
+				pdu.Add((byte)0x00);
+			}
+			
+			pdu.Add((byte)DataCoding);
+			pdu.Add(SmDefaultMessageId);
+			_SmLength = PduUtil.InsertShortMessage(pdu, ShortMessage);
+			
+			pdu.TrimToSize();
+			
+			return pdu;
+		}
+	}
+}
diff --git a/Packet/Request/MessageLcd3.cs b/Packet/Request/MessageLcd3.cs
new file mode 100644
index 0000000..31b15ca
--- /dev/null
+++ b/Packet/Request/MessageLcd3.cs
@@ -0,0 +1,601 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Provides some common attributes for data_sm, submit_sm, and submit_multi.
+	/// </summary>
+	public abstract class MessageLcd3 : MessageLcd4
+	{
+		#region private fields
+
+		private string _ServiceType = string.Empty;
+		private byte _EsmClass = 0;
+		private DataCodingType _DataCoding = Pdu.DataCodingType.SMSCDefault;
+		
+		#endregion private fields
+		
+		#region constants
+		
+		private const int SAR_MIN = 1;
+		private const int SAR_MAX = 255;
+		
+		#endregion constants
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// The service type of the message.  Null values are treated as empty strings.
+		/// </summary>
+		public string ServiceType
+		{
+			get
+			{				
+				return _ServiceType;
+			}
+			
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= SERVICE_TYPE_LENGTH)
+					{
+						_ServiceType = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException("Service Type must be " + 
+							SERVICE_TYPE_LENGTH + " 5 characters or less.");
+					}
+				}
+				else
+				{
+					_ServiceType = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Indicates Message Mode and Message Type.  See the SMSC version 3.4 specification 
+		/// for details on setting this.
+		/// </summary>
+		public byte EsmClass
+		{
+			get
+			{
+				return _EsmClass;
+			}
+			set
+			{
+				_EsmClass = value;
+			}
+		}
+		
+		/// <summary>
+		/// Defines the encoding scheme of the short message user data.
+		/// </summary>
+		public DataCodingType DataCoding
+		{
+			get
+			{
+				return _DataCoding;
+			}
+			set
+			{
+				_DataCoding = value;
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region optional params
+		
+		/// <summary>
+		/// The application port number associated with the source address of the message.
+		/// This parameter should be present for WAP applications.
+		/// </summary>
+		public UInt16 SourcePort
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.source_port);
+			}
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.source_port, value);
+				}
+				else
+				{
+					throw new ArgumentException("source_port value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The subcomponent in the destination device which created the user data.
+		/// </summary>
+		public AddressSubunitType SourceAddressSubunit
+		{
+			get
+			{
+				return (AddressSubunitType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.source_addr_subunit)[0];
+			}
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.source_addr_subunit, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// The application port number associated with the destination address of the
+		/// message.  This parameter should be present for WAP applications.
+		/// </summary>
+		public UInt16 DestinationPort
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.destination_port);
+			}
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.destination_port, value);
+				}
+				else
+				{
+					throw new ArgumentException("destination_port value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The reference number for a particular concatenated short message.  Both
+		/// SarTotalSegments and SarSegmentSeqnum need to be set in conjunction with this
+		/// property.  In addition, this must be the same for each segment.
+		/// </summary>
+		public UInt16 SarMsgRefNumber
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.sar_msg_ref_num);
+			}
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.sar_msg_ref_num, value);
+				}
+				else
+				{
+					throw new ArgumentException("sar_msg_ref_number value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Indicates the total number of short messages within the concatenated short
+		/// message.  Both SarMsgRefNumber and SarSegmentSeqNum need to be set in
+		/// conjunction with this property.  In addition, this must be the same for each
+		/// segment.
+		/// </summary>
+		public byte SarTotalSegments
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.sar_total_segments)[0];
+			}
+			
+			set
+			{
+				if(value >= SAR_MIN && value <= SAR_MAX)
+				{
+					SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.sar_total_segments, new Byte[] {(byte)value});
+				}
+				else
+				{
+					throw new ArgumentException(
+						"sar_total_segments must be >= " + SAR_MIN + " and <= " + SAR_MAX);
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The sequence number of a particular short message within the concatenated
+		/// short message.  Both SarMsgRefNumber and SarTotalSegments need to be set in
+		/// conjunction with this property.
+		/// </summary>
+		public byte SarSegmentSeqnum
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.sar_segment_seqnum)[0];
+			}
+			
+			set
+			{
+				if(value >= SAR_MIN && value <= SAR_MAX)
+				{
+					SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.sar_segment_seqnum, new Byte[] {(byte)value});
+				}
+				else
+				{
+					throw new ArgumentException(
+						"sar_segment_seqnum must be >= " + SAR_MIN + " and <= " + SAR_MAX);
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Defines the type of payload.
+		/// </summary>
+		public PayloadTypeType PayloadType
+		{
+			get
+			{
+				return (PayloadTypeType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.payload_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.payload_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Contains the extended short message user data.  Up to 64K octets can be
+		/// transmitted.  The limit for this is network/SMSC dependent.
+		/// </summary>
+		public object MessagePayload
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.message_payload);
+			}
+			
+			set
+			{
+				PduUtil.SetMessagePayload(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// The privacy level of the message.
+		/// </summary>
+		public PrivacyType PrivacyIndicator
+		{
+			get
+			{
+				return (PrivacyType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.privacy_indicator)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.privacy_indicator, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// ESME assigned message reference number.
+		/// </summary>
+		public UInt16 UserMessageReference
+		{
+			get
+			{				
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.user_message_reference);
+			}
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.user_message_reference, value);
+				}
+				else
+				{
+					throw new ArgumentException("user_message_reference too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Allows an indication to be provided to an MS that there are
+		/// messages waiting for the subscriber on systems on the PLMN. The indication
+		/// can be an icon on the MS screen or other MMI indication.
+		/// See section 5.3.2.13 for details on how to set this.
+		/// </summary>
+		public byte MsMsgWaitFacilities
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.ms_msg_wait_facilities)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.ms_msg_wait_facilities, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// Provides a MS with validity information associated with the received
+		/// short message.
+		/// </summary>
+		public MsValidityType MsValidity
+		{
+			get
+			{
+				return (MsValidityType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.ms_validity)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.ms_validity, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Provides a TDMA MS station with alert tone information associated with the
+		/// received short message.
+		/// </summary>
+		public UInt16 SmsSignal
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.sms_signal);
+			}
+			
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.sms_signal, value);
+				}
+				else
+				{
+					throw new ArgumentException("sms_signal value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The subcomponent in the destination device for which the user data is intended.
+		/// </summary>
+		public AddressSubunitType DestinationAddrSubunit
+		{
+			get
+			{
+				return (AddressSubunitType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.dest_addr_subunit)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.dest_addr_subunit, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Tells a mobile station to alert the user when the short message arrives at the MS.
+		///
+		/// Note: there is no value part associated with this parameter.
+		/// Any value you pass in will be discarded.
+		/// </summary>
+		public byte AlertOnMsgDelivery
+		{
+			get
+			{
+				try
+				{
+					byte[] bytes = GetOptionalParamBytes(
+						(ushort)OptionalParamCodes.alert_on_message_delivery);
+					return 1;
+				}
+				catch(ApplicationException)
+				{
+					return 0;
+				}
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.alert_on_message_delivery, new Byte[0]);
+			}
+		}
+		
+		/// <summary>
+		/// The language of the short message.
+		/// </summary>
+		public LanguageType LanguageIndicator
+		{
+			get
+			{
+				return (LanguageType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.language_indicator)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.language_indicator, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Associates a display time with the short message on the MS.
+		/// </summary>
+		public DisplayTimeType DisplayTime
+		{
+			get
+			{
+				return (DisplayTimeType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.display_time)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.display_time, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Associates a call back number with the message.  See section 5.3.2.36 of the
+		/// SMPP spec for details.  This must be between 4 and 19 characters in length.
+		/// </summary>
+		public string CallbackNum
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.callback_num);
+			}
+			
+			set
+			{
+				PduUtil.SetCallbackNum(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Controls the presentation indication and screening of the CallBackNumber at the
+		/// mobile station.  You must also use the callback_num parameter with this.
+		/// See section 5.3.2.37 of the SMPP spec for details in how to set this.
+		/// </summary>
+		public byte CallbackNumPresInd
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.callback_num_pres_ind)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.callback_num_pres_ind, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// Alphanumeric display tag for call back number.  This must be less than or
+		/// equal to 65 characters in length.
+		/// </summary>
+		public string CallbackNumAtag
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.callback_num_atag);
+			}
+			
+			set
+			{
+				const int CALLBACK_ATAG_MAX = 65;
+				
+				if(value.Length <= CALLBACK_ATAG_MAX)
+				{
+					SetOptionalParamString(
+						(ushort)Pdu.OptionalParamCodes.callback_num_atag, value);
+				}
+				else
+				{
+					throw new ArgumentException("Callback number atag must be <= " + CALLBACK_ATAG_MAX + ".");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Specifies a subaddress associated with the originator of the message.
+		/// See section 5.3.2.15 of the SMPP spec for details on
+		/// setting this parameter.
+		/// </summary>
+		public string SourceSubaddress
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.source_subaddress);
+			}
+			
+			set
+			{
+				PduUtil.SetSourceSubaddress(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Specifies a subaddress associated with the receiver of the message.
+		/// See section 5.3.2.15 of the SMPP spec for details on
+		/// setting this parameter.
+		/// </summary>
+		public string DestinationSubaddress
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.dest_subaddress);
+			}
+			
+			set
+			{
+				PduUtil.SetDestSubaddress(this, value);
+			}
+		}
+		
+		#endregion optional params
+		
+		#region constructors
+		
+		/// <summary>
+		/// Groups construction tasks for subclasses.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none, 
+		/// ESM class to 0, and data coding to SMSC default.
+		/// </summary>
+		protected MessageLcd3(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new MessageLcd3 for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		protected MessageLcd3(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+	}
+}
diff --git a/Packet/Request/MessageLcd4.cs b/Packet/Request/MessageLcd4.cs
new file mode 100644
index 0000000..c3b28ab
--- /dev/null
+++ b/Packet/Request/MessageLcd4.cs
@@ -0,0 +1,72 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Provides some common attributes for data_sm, submit_sm, submit_multi,
+	/// and replace_sm.
+	/// </summary>
+	public abstract class MessageLcd4 : MessageLcd6
+	{
+		/// <summary>
+		/// The registered delivery type of the message.
+		/// </summary>
+		protected RegisteredDeliveryType _RegisteredDelivery = Pdu.RegisteredDeliveryType.None;
+		
+		#region properties
+		
+		/// <summary>
+		/// The registered delivery type of the message.
+		/// </summary>
+		public RegisteredDeliveryType RegisteredDelivery
+		{
+			get
+			{
+				return _RegisteredDelivery;
+			}
+			set
+			{
+				_RegisteredDelivery =  value;
+			}
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Groups construction tasks for subclasses.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", and registered delivery type to 
+		/// none.
+		/// </summary>
+		protected MessageLcd4(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new MessageLcd4 for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		protected MessageLcd4(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+	}
+}
diff --git a/Packet/Request/MessageLcd6.cs b/Packet/Request/MessageLcd6.cs
new file mode 100644
index 0000000..c1f9eea
--- /dev/null
+++ b/Packet/Request/MessageLcd6.cs
@@ -0,0 +1,135 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Provides some common attributes for data_sm, query_sm, submit_sm, submit_multi,
+	/// cancel_sm, and replace_sm.
+	/// </summary>
+	public abstract class MessageLcd6 : Pdu
+	{
+		#region private fields
+		
+		private TonType _SourceAddressTon = Pdu.TonType.International;
+		private NpiType _SourceAddressNpi = Pdu.NpiType.ISDN;
+		private string _SourceAddress = string.Empty;
+		
+		#endregion private fields
+		
+		#region constants
+		/// <summary>
+		/// Address length for source and destination addresses
+		/// </summary>
+		protected const int ADDRESS_LENGTH = 20;
+		/// <summary>
+		/// Message length
+		/// </summary>
+		protected const int MSG_LENGTH = 64;
+		/// <summary>
+		/// Length of service type string
+		/// </summary>
+		protected const int SERVICE_TYPE_LENGTH = 50;
+		
+		#endregion constants
+		
+		#region properties
+		
+		/// <summary>
+		/// The type of number of the source address.
+		/// </summary>
+		public TonType SourceAddressTon
+		{
+			get
+			{
+				return _SourceAddressTon;
+			}
+			set
+			{
+				_SourceAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// The number plan indicator of the source address.
+		/// </summary>
+		public NpiType SourceAddressNpi
+		{
+			get
+			{
+				return _SourceAddressNpi;
+			}
+			set
+			{
+				_SourceAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// The source address.  Null values are treated as empty strings.
+		/// </summary>
+		public string SourceAddress
+		{
+			get
+			{
+				return _SourceAddress;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= ADDRESS_LENGTH)
+					{
+						_SourceAddress = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Source Address must be <= " + ADDRESS_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_SourceAddress = string.Empty;
+				}
+			}
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Groups construction tasks for subclasses.  Sets source address TON to 
+		/// international, source address NPI to ISDN, and source address to "".
+		/// </summary>
+		protected MessageLcd6(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new MessageLcd6 for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		protected MessageLcd6(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+	}
+}
diff --git a/Packet/Request/SmppAlertNotification.cs b/Packet/Request/SmppAlertNotification.cs
new file mode 100644
index 0000000..9de4ccb
--- /dev/null
+++ b/Packet/Request/SmppAlertNotification.cs
@@ -0,0 +1,248 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Sent from the SMSC to the mobile device when the device is available and a
+	/// delivery pending flag has been set from a previous data_sm operation.
+	/// </summary>
+	public class SmppAlertNotification : Pdu
+	{
+		#region private fields
+		
+		private TonType _SourceAddressTon = TonType.International;
+		private NpiType _SourceAddressNpi = NpiType.ISDN;
+		private string _SourceAddress = string.Empty;
+		private TonType _EsmeAddressTon = TonType.International;
+		private NpiType _EsmeAddressNpi = NpiType.ISDN;
+		private string _EsmeAddress = string.Empty;
+		
+		#endregion private fields
+		
+		#region enumerations
+		
+		/// <summary>
+		/// Enumerates the availability states of the message.
+		/// </summary>
+		public enum AvailabilityStatusType : byte
+		{
+			/// <summary>
+			/// Available
+			/// </summary>
+			Available = 0x00,
+			/// <summary>
+			/// Denied
+			/// </summary>
+			Denied = 0x01,
+			/// <summary>
+			/// Unavailable
+			/// </summary>
+			Unavailable = 0x02
+		}
+		
+		#endregion enumerations
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// Enumerates the type of number.
+		/// </summary>
+		public TonType SourceAddressTon
+		{
+			get
+			{
+				return _SourceAddressTon;
+			}
+			
+			set
+			{
+				_SourceAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// Enumerates the numbering plan indicator.
+		/// </summary>
+		public NpiType SourceAddressNpi
+		{
+			get
+			{
+				return _SourceAddressNpi;
+			}
+			
+			set
+			{
+				_SourceAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// Address of sending entity.
+		/// </summary>
+		public string SourceAddress
+		{
+			get
+			{
+				return _SourceAddress;
+			}
+			
+			set
+			{
+				_SourceAddress = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// The type of number for the destination address that requested an alert.
+		/// </summary>
+		public TonType EsmeAddressTon
+		{
+			get
+			{
+				return _EsmeAddressTon;
+			}
+			
+			set
+			{
+				_EsmeAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// The numbering plan indicator for the destination address that requested an alert.
+		/// </summary>
+		public NpiType EsmeAddressNpi
+		{
+			get
+			{
+				return _EsmeAddressNpi;
+			}
+			
+			set
+			{
+				_EsmeAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// The source address of the device that requested an alert.
+		/// </summary>
+		public string EsmeAddress
+		{
+			get
+			{
+				return _EsmeAddress;
+			}
+			
+			set
+			{				
+				_EsmeAddress = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region optional parameters
+		
+		/// <summary>
+		/// The status of the mobile station.
+		/// </summary>
+		public AvailabilityStatusType MSAvailabilityStatus
+		{
+			get
+			{
+				return(AvailabilityStatusType)GetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.ms_availability_status)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.ms_availability_status, new Byte[] {(byte)value});
+			}
+		}
+		
+		#endregion optional parameters
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates an SMPP Alert Notification Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppAlertNotification(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates an SMPP Alert Notification Pdu.
+		/// </summary>
+		public SmppAlertNotification(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the alert_notification from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			EsmeAddressTon =(TonType)remainder[0];
+			EsmeAddressNpi =(NpiType)remainder[1];
+			EsmeAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.alert_notification;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.Add((byte)EsmeAddressTon);
+			pdu.Add((byte)EsmeAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(EsmeAddress)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Request/SmppBind.cs b/Packet/Request/SmppBind.cs
new file mode 100644
index 0000000..c4889aa
--- /dev/null
+++ b/Packet/Request/SmppBind.cs
@@ -0,0 +1,343 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Class for a bind request Pdu.
+	/// </summary>
+	public class SmppBind : Pdu
+	{
+		#region private fields
+		
+		private string _SystemId = string.Empty;
+		private string _Password = string.Empty;
+		private string _SystemType = string.Empty;
+		private string _AddressRange = string.Empty;
+		private SmppVersionType _InterfaceVersion = Pdu.SmppVersionType.Version3_4;
+		private TonType _AddressTon = Pdu.TonType.International;
+		private NpiType _AddressNpi = Pdu.NpiType.ISDN;
+		private BindingType _BindType = BindingType.BindAsTransceiver;
+		
+		#endregion private fields
+		
+		#region constants
+		
+		private const int ID_LENGTH = 15;
+		private const int PASS_LENGTH = 8;
+		private const int TYPE_LENGTH = 12;
+		private const int RANGE_LENGTH = 40;
+		
+		#endregion constants
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// The binding type: transmitter, receiver, or transceiver.
+		/// </summary>
+		public BindingType BindType
+		{
+			get
+			{
+				return _BindType;
+			}
+			set
+			{
+				switch(value)
+				{
+					case BindingType.BindAsReceiver:
+					{
+						CommandID = CommandIdType.bind_receiver;
+						break;
+					}
+					case BindingType.BindAsTransceiver:
+					{
+						CommandID = CommandIdType.bind_transceiver;
+						break;
+					}
+					case BindingType.BindAsTransmitter:
+					{
+						CommandID = CommandIdType.bind_transmitter;
+						break;
+					}
+					default:
+					{
+						CommandID = CommandIdType.bind_transmitter;
+						break;
+					}	
+				}
+				
+				_BindType = value;
+			}
+		}
+		
+		/// <summary>
+		/// The ESME system requesting to bind with the SMSC.  Set to null for default value.
+		/// </summary>
+		public string SystemId
+		{
+			get
+			{
+				return _SystemId;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= ID_LENGTH)
+						_SystemId = value;
+					else
+						throw new ArgumentOutOfRangeException("System ID must be <= "+ 
+							ID_LENGTH + " characters).");
+				}
+				else
+					_SystemId = "";
+			}
+		}
+		
+		/// <summary>
+		/// Used by the SMSC to authenticate the ESME requesting to bind.  
+		/// Set to null for default value.
+		/// </summary>
+		public string Password
+		{
+			get
+			{
+				return _Password;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= PASS_LENGTH)
+					{
+						_Password = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException("Password must be <= "+ PASS_LENGTH + " characters).");
+					}
+				}
+				else
+				{
+					_Password = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The type of ESME system requesting to bind with the SMSC.  
+		/// Set to null for default value.
+		/// </summary>
+		public string SystemType
+		{
+			get
+			{
+				return _SystemType;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= TYPE_LENGTH)
+					{
+						_SystemType = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException("System type must be <= "+ TYPE_LENGTH + " characters).");
+					}
+				}
+				else
+				{
+					_SystemType = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The ESME address range.  If not known, set to null.
+		/// </summary>
+		public string AddressRange
+		{
+			get
+			{
+				return _AddressRange;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= RANGE_LENGTH)
+					{
+						_AddressRange = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException("Address range must be <= "+ RANGE_LENGTH + " characters).");
+					}
+				}
+				else
+				{
+					_AddressRange = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The version of the SMPP protocol supported by the ESME.
+		/// </summary>
+		public SmppVersionType InterfaceVersion
+		{
+			get
+			{
+				return _InterfaceVersion;
+			}
+			set
+			{
+				_InterfaceVersion = value;
+			}
+		}
+		
+		/// <summary>
+		/// Indicates type of number of ESME address.
+		/// </summary>
+		public TonType AddressTon
+		{
+			get
+			{
+				return _AddressTon;
+			}
+			set
+			{
+				_AddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering plan indicator for ESME address.
+		/// </summary>
+		public NpiType AddressNpi
+		{
+			get
+			{
+				return _AddressNpi;
+			}
+			set
+			{
+				_AddressNpi = value;
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region enumerations
+		
+		/// <summary>
+		/// Binding types for the SMPP bind request.
+		/// </summary>
+		public enum BindingType : uint
+		{
+			/// <summary>
+			/// BindAsReceiver
+			/// </summary>
+			BindAsReceiver = 1,
+			/// <summary>
+			/// BindAsTransmitter
+			/// </summary>
+			BindAsTransmitter = 2,
+			/// <summary>
+			/// BindAsTransceiver
+			/// </summary>
+			BindAsTransceiver = 9
+		}
+		
+		#endregion enumerations
+		
+		#region constructors
+		
+		/// <summary>
+		/// Constructs a bind request.  Sets system ID, password, system type, and address 
+		/// range to empty strings.  Sets interface version to v3.4, address TON to 
+		/// international, address NPI to ISDN, and sets to bind as a transceiver.
+		/// </summary>
+		public SmppBind(): base()
+		{}
+		
+		/// <summary>
+		/// Constructs a bind request.  Sets system ID, password, system type, and address 
+		/// range to empty strings.  Sets interface version to v3.4, address TON to 
+		/// international, address NPI to ISDN, and sets to bind as a transceiver.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes from an ESME.</param>
+		public SmppBind(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			BindType = BindingType.BindAsTransceiver;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SystemId)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(Password)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SystemType)));
+			pdu.Add((byte)InterfaceVersion);
+			pdu.Add((byte)AddressTon);
+			pdu.Add((byte)AddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(AddressRange)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the submit_sm Pdu.  The Pdu has basically the same format as
+		/// the submit_sm Pdu, but in this case it is a response.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			BindType = (SmppBind.BindingType)CommandID;
+			SystemId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			Password = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SystemType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			InterfaceVersion =(SmppVersionType)remainder[0];
+			AddressTon =(TonType)remainder[1];
+			AddressNpi =(NpiType)remainder[2];
+			AddressRange = SmppStringUtil.GetCStringFromBody(ref remainder, 3);
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppCancelSm.cs b/Packet/Request/SmppCancelSm.cs
new file mode 100644
index 0000000..28f6a62
--- /dev/null
+++ b/Packet/Request/SmppCancelSm.cs
@@ -0,0 +1,253 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Cancels one or more previous short messages. A particular message or all messages
+	/// for a particular source, destination and service_type can be cancelled.
+	///
+	/// From the SMPP spec:
+	///  If the message_id is set to the ID of a previously submitted message, then
+	/// provided the source address supplied by the ESME matches that of the stored
+	/// message, that message will be cancelled.
+	///  If the message_id is null, all outstanding undelivered messages with matching
+	/// source and destination addresses given in the Pdu are cancelled. If provided,
+	/// service_type is included in this matching.
+	/// Where the original submit_sm, data_sm or submit_multi source address was
+	/// defaulted to null, then the source address in the cancel_sm command should also
+	/// be null.
+	/// </summary>
+	public class SmppCancelSm : MessageLcd6
+	{
+		#region private fields
+		
+		private string _MessageId = string.Empty;
+		private string _ServiceType = string.Empty;
+		private TonType _DestinationAddressTon = Pdu.TonType.International;
+		private NpiType _DestinationAddressNpi = Pdu.NpiType.ISDN;
+		private string _DestinationAddress = string.Empty;
+		
+		#endregion private fields
+		
+		#region properties
+		
+		/// <summary>
+		/// Message ID of the message to be cancelled. This must be the SMSC assigned Message 
+		/// ID of the original message.  Set to null if cancelling a group of messages.
+		/// </summary>
+		public string MessageId
+		{ 
+			get 
+			{ 
+				return _MessageId; 
+			} 
+			set 
+			{ 
+				if(value != null)
+				{
+					if(value.Length <= MSG_LENGTH)
+					{
+						_MessageId = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Message ID must be <= " + MSG_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_MessageId = string.Empty;
+				}
+			} 
+		}
+		
+		/// <summary>
+		/// Set to indicate SMS Application service, if cancellation of a group of application 
+		/// service messages is desired.  Otherwise set to null.
+		/// </summary>
+		public string ServiceType
+		{ 
+			get 
+			{ 
+				return _ServiceType; 
+			} 
+			set 
+			{
+				if(value != null)
+				{
+					if(value.Length <= SERVICE_TYPE_LENGTH)
+					{
+						_ServiceType = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Service Type must be <= " + SERVICE_TYPE_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_ServiceType = string.Empty;
+				}
+			} 
+		}
+		
+		/// <summary>
+		/// Type of number of destination SME address of the message(s)to be cancelled.  
+		/// This must match that supplied in the original message submission request.  
+		/// This can be set to null if the message ID is provided.
+		/// </summary>
+		public TonType DestinationAddressTon
+		{ 
+			get 
+			{ 
+				return _DestinationAddressTon; 
+			} 
+			set 
+			{
+				_DestinationAddressTon = value; 
+			} 
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator of destination SME address of the message(s))to be 
+		/// cancelled.  This must match that supplied in the original message submission request.  
+		/// This can be set to null when the message ID is provided.
+		/// </summary>
+		public NpiType DestinationAddressNpi
+		{ 
+			get 
+			{ 
+				return _DestinationAddressNpi; 
+			} 
+			set 
+			{ 
+				_DestinationAddressNpi = value; 
+			} 
+		}
+		
+		/// <summary>
+		/// Destination address of message(s)to be cancelled.  This must match that supplied in 
+		/// the original message submission request. This can be set to null when the message ID 
+		/// is provided.
+		/// </summary>
+		public string DestinationAddress
+		{ 
+			get 
+			{ 
+				return _DestinationAddress; 
+			} 
+			set 
+			{
+				if(value != null)
+				{
+					if(value.Length <= ADDRESS_LENGTH)
+					{
+						_DestinationAddress = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Destination Address must be <= " + ADDRESS_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_DestinationAddress = string.Empty;
+				}
+			} 
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates an SMPP Cancel SM Pdu.  Sets message ID and service type to empty strings 
+		///(null), sets the destination TON to international and the destination NPI to ISDN, 
+		/// and sets the command status to 0.
+		/// </summary>
+		public SmppCancelSm(): base()
+		{}
+		
+		/// <summary>
+		/// Creates an SMPP Cancel SM Pdu.  Sets message ID and service type to empty strings 
+		///(null), sets the destination TON to international and the destination NPI to ISDN, 
+		/// and sets the command status to 0.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppCancelSm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.cancel_sm;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ServiceType)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.Add((byte)DestinationAddressTon);
+			pdu.Add((byte)DestinationAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(DestinationAddress)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the cancel_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			ServiceType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			MessageId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			DestinationAddressTon =(TonType)remainder[0];
+			DestinationAddressNpi =(NpiType)remainder[1];
+			DestinationAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppDataSm.cs b/Packet/Request/SmppDataSm.cs
new file mode 100644
index 0000000..579bfb3
--- /dev/null
+++ b/Packet/Request/SmppDataSm.cs
@@ -0,0 +1,516 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using RoaminSMPP.Utility;
+using System.Collections;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// This command is used to transfer data between the SMSC and the ESME(and can be
+	/// used by both).  This is an alternative to the submit_sm and deliver_sm commands.
+	/// </summary>
+	public class SmppDataSm : MessageLcd3
+	{
+		private TonType _DestinationAddressTon = Pdu.TonType.International;
+		private NpiType _DestinationAddressNpi = Pdu.NpiType.ISDN;
+		private string _DestinationAddress = string.Empty;
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// Type of number of destination SME address of the message(s)to be cancelled.  
+		/// This must match that supplied in the original message submission request.  
+		/// This can be set to null if the message ID is provided.
+		/// </summary>
+		public TonType DestinationAddressTon
+		{ 
+			get 
+			{ 
+				return _DestinationAddressTon; 
+			} 
+			set 
+			{
+				_DestinationAddressTon = value; 
+			} 
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator of destination SME address of the message(s))to be 
+		/// cancelled.  This must match that supplied in the original message submission request.  
+		/// This can be set to null when the message ID is provided.
+		/// </summary>
+		public NpiType DestinationAddressNpi
+		{ 
+			get 
+			{ 
+				return _DestinationAddressNpi; 
+			} 
+			set 
+			{ 
+				_DestinationAddressNpi = value; 
+			} 
+		}
+		
+		/// <summary>
+		/// Destination address of message(s)to be cancelled.  This must match that supplied in 
+		/// the original message submission request. This can be set to null when the message ID 
+		/// is provided.
+		/// </summary>
+		public string DestinationAddress
+		{ 
+			get 
+			{ 
+				return _DestinationAddress; 
+			} 
+			set 
+			{
+				if(value != null)
+				{
+					if(value.Length <= ADDRESS_LENGTH)
+					{
+						_DestinationAddress = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Destination Address must be <= " + ADDRESS_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_DestinationAddress = string.Empty;
+				}
+			} 
+		}
+		
+		#endregion mandatory parameters
+		
+		#region optional params
+		
+		/// <summary>
+		/// The correct network associated with the originating device.
+		/// </summary>
+		public NetworkType SourceNetworkType
+		{
+			get
+			{
+				return(NetworkType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.source_network_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.source_network_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// The correct bearer type for the delivering the user data to the destination.
+		/// </summary>
+		public BearerType SourceBearerType
+		{
+			get
+			{
+				return(BearerType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.source_bearer_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.source_bearer_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// The telematics identifier associated with the source.  The value part
+		/// has yet to be defined in the specs as of 07/20/2004.
+		/// </summary>
+		public UInt16 SourceTelematicsId
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.source_telematics_id);
+			}
+			
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetOptionalParamBytes(
+						(UInt16)Pdu.OptionalParamCodes.source_telematics_id,
+						BitConverter.GetBytes(
+						UnsignedNumConverter.SwapByteOrdering(value)));
+				}
+				else
+				{
+					throw new ArgumentException("source_telematics_id value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The correct network for the destination device.
+		/// </summary>
+		public NetworkType DestNetworkType
+		{
+			get
+			{
+				return(NetworkType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.dest_network_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.dest_network_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// The correct bearer type for the delivering the user data to the destination.
+		/// </summary>
+		public BearerType DestBearerType
+		{
+			get
+			{
+				return(BearerType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.dest_bearer_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.dest_bearer_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// The telematics identifier associated with the destination.  The value part
+		/// has yet to be defined in the specs as of 07/20/2004.
+		/// </summary>
+		public UInt16 DestTelematicsId
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)Pdu.OptionalParamCodes.dest_telematics_id);
+			}
+			
+			set
+			{
+				if(value < UInt16.MaxValue)
+				{
+					SetOptionalParamBytes(
+						(UInt16)Pdu.OptionalParamCodes.dest_telematics_id,
+						BitConverter.GetBytes(
+						UnsignedNumConverter.SwapByteOrdering(value)));
+				}
+				else
+				{
+					throw new ArgumentException("dest_telematics_id value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// If true, this indicates that there are more messages to follow for the
+		/// destination SME.
+		/// </summary>
+		public bool MoreMessagesToSend
+		{
+			get
+			{
+				byte sendMore = GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.more_messages_to_send)[0];
+				
+				return (sendMore == 0) ? false : true;
+			}
+			
+			set
+			{
+				byte sendMore;
+				if(value == false)
+				{
+					sendMore =(byte)0x00;
+				}
+				else
+				{
+					sendMore =(byte)0x01;
+				}
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.more_messages_to_send, new Byte[] {sendMore});
+			}
+		}
+		
+		/// <summary>
+		/// Time to live as a relative time in seconds from submission.
+		/// </summary>
+		public UInt32 QosTimeToLive
+		{
+			get
+			{
+				return GetHostOrderUInt32FromTlv((ushort)Pdu.OptionalParamCodes.qos_time_to_live);
+			}
+			
+			set
+			{
+				if(value < UInt32.MaxValue)
+				{
+					SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.qos_time_to_live,
+						BitConverter.GetBytes(
+						UnsignedNumConverter.SwapByteOrdering(value)));
+				}
+				else
+				{
+					throw new ArgumentException("qos_time_to_live value too large.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Sets the Delivery Pending Flag on delivery failure.
+		/// </summary>
+		public DpfResultType SetDpf
+		{
+			get
+			{
+				return(DpfResultType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.set_dpf)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.set_dpf, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// SMSC message ID of message being receipted.  Should be present for SMSC
+		/// Delivery Receipts and Intermediate Notifications.
+		/// </summary>
+		public string ReceiptedMessageId
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)Pdu.OptionalParamCodes.receipted_message_id);
+			}
+			
+			set
+			{
+				PduUtil.SetReceiptedMessageId(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Message State.  Should be present for SMSC Delivery Receipts and Intermediate
+		/// Notifications.
+		/// </summary>
+		public MessageStateType MessageState
+		{
+			get
+			{
+				return (MessageStateType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.message_state)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.message_state, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Network error code.  May be present for SMSC Delivery Receipts and
+		/// Intermediate Notifications.  See section 5.3.2.31 for more information.
+		/// </summary>
+		public string NetworkErrorCode
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)Pdu.OptionalParamCodes.network_error_code);
+			}
+			
+			set
+			{
+				PduUtil.SetNetworkErrorCode(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// A user response code. The actual response codes are implementation specific.
+		/// </summary>
+		public byte UserResponseCode
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.user_response_code)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.user_response_code,new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// Indicates the number of messages stored in a mail box.
+		/// </summary>
+		public byte NumberOfMessages
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.number_of_messages)[0];
+			}
+			
+			set
+			{
+				if(value <= 99)
+				{
+					SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.number_of_messages, new Byte[] {value});
+				}
+				else
+				{
+					throw new ArgumentException("number_of_messages must be between 0 and 99.");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Indicates and controls the MS users reply method to an SMS delivery message
+		/// received from the network.
+		/// </summary>
+		public ItsReplyTypeType ItsReplyType
+		{
+			get
+			{
+				return (ItsReplyTypeType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.its_reply_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.its_reply_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Session control information for Interactive Teleservice.
+		///
+		/// See section 5.3.2.43 of the SMPP spec for how to set this.
+		/// </summary>
+		public string ItsSessionInfo
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)Pdu.OptionalParamCodes.its_session_info);
+			}
+			
+			set
+			{
+				PduUtil.SetItsSessionInfo(this, value);
+			}
+		}
+		
+		#endregion optional params
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a data_sm Pdu.  Sets the destination TON to international, the destination 
+		/// NPI to ISDN, and the command status to 0.
+		/// </summary>
+		public SmppDataSm(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a data_sm Pdu.  Sets the destination TON to international, the destination 
+		/// NPI to ISDN, and the command status to 0.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppDataSm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.data_sm;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ServiceType)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.Add((byte)DestinationAddressTon);
+			pdu.Add((byte)DestinationAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(DestinationAddress)));
+			pdu.Add(EsmClass);
+			pdu.Add((byte)RegisteredDelivery);
+			pdu.Add((byte)DataCoding);
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the cancel_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			#if DEBUG
+			Console.WriteLine("In DecodeSmscResponse of EsmppDataSm");
+			#endif
+			byte[] remainder = BytesAfterHeader;
+			ServiceType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon = (TonType)remainder[0];
+			SourceAddressNpi = (NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			DestinationAddressTon = (TonType)remainder[0];
+			DestinationAddressNpi = (NpiType)remainder[1];
+			DestinationAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			EsmClass = remainder[0];
+			RegisteredDelivery = (RegisteredDeliveryType)remainder[1];
+			DataCoding = (DataCodingType)remainder[2];
+			
+			TranslateTlvDataIntoTable(remainder, 3);
+		}
+	}
+}
diff --git a/Packet/Request/SmppDeliverSm.cs b/Packet/Request/SmppDeliverSm.cs
new file mode 100644
index 0000000..83c1f79
--- /dev/null
+++ b/Packet/Request/SmppDeliverSm.cs
@@ -0,0 +1,678 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using RoaminSMPP.Utility;
+using RoaminSMPP.Packet;
+using System.Collections;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// This class defines a deliver_sm that is SMSC generated.  This does
+	/// NOT handle anything other than strings in the short message.
+	/// </summary>
+	public class SmppDeliverSm : Pdu
+	{
+		#region private fields
+		
+		private string _ServiceType = string.Empty;
+		private TonType _SourceAddressTon = TonType.International;
+		private NpiType _SourceAddressNpi = NpiType.ISDN;
+		private string _SourceAddress = string.Empty;
+		private TonType _DestinationAddressTon = TonType.International;
+		private NpiType _DestinationAddressNpi = NpiType.ISDN;
+		private string _DestinationAddress = string.Empty;
+		private byte _EsmClass = 0;
+		private SmppVersionType _ProtocolId = SmppVersionType.Version3_4;
+		private PriorityType _PriorityFlag = PriorityType.Lowest;
+		private RegisteredDeliveryType _RegisteredDelivery = RegisteredDeliveryType.None;
+		private DataCodingType _DataCoding = DataCodingType.SMSCDefault;
+		private byte _SmLength = 0;
+		private string _ShortMessage = null;
+		
+		#endregion private fields
+		
+		/// <summary>
+		/// Used to indicate the SMS Application service associated with the message.
+		/// If this is unknown, null is returned.
+		/// </summary>
+		public string ServiceType
+		{
+			get
+			{
+				return _ServiceType;
+			}
+			
+			set
+			{
+				_ServiceType = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Type of Number for source address.
+		/// </summary>
+		public TonType SourceAddressTon
+		{
+			get
+			{
+				return _SourceAddressTon;
+			}
+			
+			set
+			{
+				_SourceAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator for source address.
+		/// </summary>
+		public NpiType SourceAddressNpi
+		{
+			get
+			{
+				return _SourceAddressNpi;
+			}
+			
+			set
+			{
+				_SourceAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// Address of origination entity.
+		/// </summary>
+		public string SourceAddress
+		{
+			get
+			{
+				return _SourceAddress;
+			}
+			
+			set
+			{
+				_SourceAddress = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Type of number of destination entity.
+		/// </summary>
+		public TonType DestinationAddressTon
+		{
+			get
+			{
+				return _DestinationAddressTon;
+			}
+			
+			set
+			{
+				_DestinationAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator of destination entity.
+		/// </summary>
+		public NpiType DestinationAddressNpi
+		{
+			get
+			{
+				return _DestinationAddressNpi;
+			}
+			
+			set
+			{
+				_DestinationAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// Destination address of entity.
+		/// </summary>
+		public string DestinationAddress
+		{
+			get
+			{
+				return _DestinationAddress;
+			}
+			
+			set
+			{
+				_DestinationAddress = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Indicates Message Mode and Message Type.  See the SMSC
+		/// version 3.4 specification for details on this.
+		/// </summary>
+		public byte EsmClass
+		{
+			get
+			{
+				return _EsmClass;
+			}
+			
+			set
+			{
+				_EsmClass = value;
+			}
+		}
+		
+		/// <summary>
+		/// Protocol Identifier; network specific.
+		/// </summary>
+		public SmppVersionType ProtocolId
+		{
+			get
+			{
+				return _ProtocolId;
+			}
+			
+			set
+			{
+				_ProtocolId = value;
+			}
+		}
+		
+		/// <summary>
+		/// Designates the priority level of the message.
+		/// </summary>
+		public PriorityType PriorityFlag
+		{
+			get
+			{
+				return _PriorityFlag;
+			}
+			
+			set
+			{
+				_PriorityFlag = value;
+			}
+		}
+		
+		/// <summary>
+		/// Use this to indicate if you want delivery confirmation.
+		/// </summary>
+		public RegisteredDeliveryType RegisteredDelivery
+		{
+			get
+			{
+				return _RegisteredDelivery;
+			}
+			
+			set
+			{
+				_RegisteredDelivery = value;
+			}
+		}
+		
+		/// <summary>
+		/// Indicates the encoding scheme of the short message.
+		/// </summary>
+		public DataCodingType DataCoding
+		{
+			get
+			{
+				return _DataCoding;
+			}
+			
+			set
+			{
+				_DataCoding = value;
+			}
+		}
+		
+		/// <summary>
+		/// Short message length in octets(bytes for x86).
+		/// </summary>
+		public byte SmLength
+		{
+			get
+			{
+				return _SmLength;
+			}
+		}
+		
+		/// <summary>
+		/// The short message for this Pdu.  This holds up to 160 characters.
+		/// If the message is longer, the MessagePayload property will be used.
+		/// If this is the case, the short message length will be zero.  Note
+		/// that both the ShortMessage and MessagePayload cannot be used
+		/// simultaneously.
+		/// </summary>
+		public string ShortMessage
+		{
+			get
+			{
+				return _ShortMessage;
+			}
+			
+			set
+			{
+				_ShortMessage = value;
+			}
+		}
+		
+		#region optional parameters
+		
+		/// <summary>
+		/// The message reference number assigned by the ESME.
+		/// </summary>
+		public UInt16 UserMessageReference
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)OptionalParamCodes.user_message_reference);
+			}
+			
+			set
+			{
+				SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.user_message_reference, value);
+			}
+		}
+		
+		/// <summary>
+		/// The port number associated with the source address of the message.  This
+		/// parameter will be present for WAP applications.
+		/// </summary>
+		public UInt16 SourcePort
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)OptionalParamCodes.source_port);
+			}
+			
+			set
+			{
+				SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.source_port, value);
+			}
+		}
+		
+		/// <summary>
+		/// The port number associated with the destination address of the message.  This
+		/// parameter will be present for WAP applications.
+		/// </summary>
+		public UInt16 DestinationPort
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)OptionalParamCodes.destination_port);
+			}
+			
+			set
+			{
+				SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.destination_port, value);
+			}
+		}
+		
+		/// <summary>
+		/// The reference number for a particular concatenated short message.
+		/// </summary>
+		public UInt16 SarMsgRefNumber
+		{
+			get
+			{
+				return GetHostOrderUInt16FromTlv((ushort)OptionalParamCodes.sar_msg_ref_num);
+			}
+			
+			set
+			{
+				SetHostOrderValueIntoTlv((UInt16)Pdu.OptionalParamCodes.sar_msg_ref_num, value);
+			}
+		}
+		
+		/// <summary>
+		/// Total number of short message fragments within the concatenated short message.
+		/// </summary>
+		public byte SarTotalSegments
+		{
+			get
+			{
+				return GetOptionalParamBytes((ushort)OptionalParamCodes.sar_total_segments)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.sar_total_segments, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// The sequence number of a particular short message fragment within the 
+		/// concatenated short message.
+		/// </summary>
+		public byte SarSegmentSeqnum
+		{
+			get
+			{
+				return GetOptionalParamBytes((ushort)OptionalParamCodes.sar_segment_seqnum)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.sar_segment_seqnum, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// A user response code. The actual response codes are SMS application specific.
+		/// </summary>
+		public byte UserResponseCode
+		{
+			get
+			{
+				return GetOptionalParamBytes((ushort)OptionalParamCodes.user_response_code)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.user_response_code, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// Indicates a level of privacy associated with the message.
+		/// </summary>
+		public PrivacyType PrivacyIndicator
+		{
+			get
+			{
+				return(PrivacyType)
+					GetOptionalParamBytes((ushort)OptionalParamCodes.privacy_indicator)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.privacy_indicator, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Defines the type of payload(e.g. WDP, WCMP, etc.)
+		/// </summary>
+		public PayloadTypeType PayloadType
+		{
+			get
+			{
+				return(PayloadTypeType)
+					GetOptionalParamBytes((ushort)OptionalParamCodes.payload_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.payload_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// This can hold up to 64K octets of short message data.
+		/// The actual limit is network/SMSC dependent.
+		/// </summary>
+		public string MessagePayload
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.message_payload);
+			}
+			
+			set
+			{
+				PduUtil.SetMessagePayload(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Associates a callback number with a message.  See section 5.3.2.36 of the
+		/// SMPP spec for details.  This must be between 4 and 19 characters in length.
+		/// </summary>
+		public string CallbackNum
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.callback_num);
+			}
+			
+			set
+			{
+				PduUtil.SetCallbackNum(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Specifies a source subaddress associated with the originating entity.
+		/// See section 5.3.2.15 of the SMPP spec for details on setting this parameter.
+		/// </summary>
+		public string SourceSubaddress
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.source_subaddress);
+			}
+			
+			set
+			{
+				PduUtil.SetSourceSubaddress(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Specifies a source subaddress associated with the receiving entity.
+		/// See section 5.3.2.15 of the SMPP spec for details on setting this parameter.
+		/// </summary>
+		public string DestinationSubaddress
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.dest_subaddress);
+			}
+			
+			set
+			{
+				PduUtil.SetDestSubaddress(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// The language of the short message.
+		/// </summary>
+		public LanguageType LanguageIndicator
+		{
+			get
+			{
+				return(LanguageType)
+					GetOptionalParamBytes((ushort)OptionalParamCodes.language_indicator)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.language_indicator, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// From the SMPP spec:
+		/// The its_session_info parameter is a required parameter for the CDMA Interactive
+		/// Teleservice as defined by the Korean PCS carriers [KORITS]. It contains control
+		/// information for the interactive session between an MS and an ESME.
+		///
+		/// See section 5.3.2.43 of the SMPP spec for how to set this.
+		/// </summary>
+		public string ItsSessionInfo
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.its_session_info);
+			}
+			
+			set
+			{
+				PduUtil.SetItsSessionInfo(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Network Error Code.  May be present for Intermediate Notifications
+		/// and SMSC Delivery Receipts.  See SMPP spec 5.3.2.31 for details.
+		/// </summary>
+		public string NetworkErrorCode
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.network_error_code);
+			}
+			
+			set
+			{
+				PduUtil.SetNetworkErrorCode(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Indicates to the ESME the final message state for an SMSC Delivery Receipt.
+		/// </summary>
+		public MessageStateType MessageState
+		{
+			get
+			{
+				return(MessageStateType)
+					GetOptionalParamBytes((ushort)OptionalParamCodes.message_state)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.message_state, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// Indicates the ID of the message being receipted in an SMSC Delivery Receipt.
+		/// </summary>
+		public string ReceiptedMessageId
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.receipted_message_id);
+			}
+			
+			set
+			{
+				PduUtil.SetReceiptedMessageId(this, value);
+			}
+		}
+		
+		#endregion optional parameters
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a deliver_sm Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppDeliverSm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a deliver_sm Pdu.
+		/// </summary>
+		public SmppDeliverSm(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// This decodes the deliver_sm Pdu.  The Pdu has basically the same format as
+		/// the submit_sm Pdu, but in this case it is a response.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			ServiceType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon = (TonType)remainder[0];
+			SourceAddressNpi = (NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			DestinationAddressTon = (TonType)remainder[0];
+			DestinationAddressNpi = (NpiType)remainder[1];
+			DestinationAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			EsmClass = remainder[0];
+			ProtocolId = (SmppVersionType)remainder[1];
+			PriorityFlag = (PriorityType)remainder[2];
+			//schedule_delivery_time and validity_period are null, so don't bother
+			//reading them
+			RegisteredDelivery = (RegisteredDeliveryType)remainder[5];
+			//replace_if_present is always null, so don't bother reading it
+			DataCoding = (DataCodingType)remainder[7];
+			//sm_default_msg_id is always null, so don't bother reading it
+			_SmLength = remainder[9];
+			ShortMessage = SmppStringUtil.GetStringFromBody(ref remainder, 10, 10 + _SmLength);
+			TranslateTlvDataIntoTable(remainder);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.deliver_sm;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ServiceType)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.Add((byte)DestinationAddressTon);
+			pdu.Add((byte)DestinationAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(DestinationAddress)));
+			pdu.Add(EsmClass);
+			pdu.Add((byte)ProtocolId);
+			pdu.Add((byte)PriorityFlag);
+			//schedule_delivery_time and validity_period are null, so set them to zero
+			pdu.Add((byte)0);
+			pdu.Add((byte)0);
+			pdu.Add((byte)RegisteredDelivery);
+			//replace_if_present is always null, so set it to zero
+			pdu.Add((byte)0);
+			pdu.Add((byte)DataCoding);
+			//sm_default_msg_id is always null, so set it to zero
+			pdu.Add((byte)0);
+			_SmLength = PduUtil.InsertShortMessage(pdu, ShortMessage);
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Request/SmppEnquireLink.cs b/Packet/Request/SmppEnquireLink.cs
new file mode 100644
index 0000000..f3f30ff
--- /dev/null
+++ b/Packet/Request/SmppEnquireLink.cs
@@ -0,0 +1,76 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Packet;
+using System.Collections;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Defines the SMPP enquire_link Pdu.  This is basically just the header.
+	/// </summary>
+	public class SmppEnquireLink : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates an enquire_link Pdu.  Sets command status and command ID.
+		/// </summary>
+		public SmppEnquireLink(): base()
+		{}
+		
+		/// <summary>
+		/// Creates an enquire_link Pdu.  Sets command status and command ID.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppEnquireLink(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.enquire_link;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the query_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppGenericNack.cs b/Packet/Request/SmppGenericNack.cs
new file mode 100644
index 0000000..8f270d5
--- /dev/null
+++ b/Packet/Request/SmppGenericNack.cs
@@ -0,0 +1,76 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Utility;
+using System.Collections;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Class to represent a generic negative acknowledgment.
+	/// </summary>
+	public class SmppGenericNack : Pdu
+	{		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a new generic NACK.  Sets the error code to 0.
+		/// </summary>
+		public SmppGenericNack(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new generic NACK.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes from the ESME.</param>
+		public SmppGenericNack(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.generic_nack;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the query_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppOutbind.cs b/Packet/Request/SmppOutbind.cs
new file mode 100644
index 0000000..f9f8ab1
--- /dev/null
+++ b/Packet/Request/SmppOutbind.cs
@@ -0,0 +1,116 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Defines an outbind response(really a request TO us)from the SMSC.
+	/// </summary>
+	public class SmppOutbind : Pdu
+	{
+		private string _SystemId = string.Empty;
+		private string _Password = string.Empty;
+		
+		/// <summary>
+		/// The ID of the SMSC.
+		/// </summary>
+		public string SystemId
+		{
+			get
+			{
+				return _SystemId;
+			}
+			
+			set
+			{
+				_SystemId = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Password that the ESME can use for authentication.
+		/// </summary>
+		public string Password
+		{
+			get
+			{
+				return _Password;
+			}
+			
+			set
+			{
+				_Password = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates an outbind response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppOutbind(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates an outbind response Pdu.
+		/// </summary>
+		public SmppOutbind(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the outbind response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			SystemId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			Password = SmppStringUtil.GetCStringFromBody(ref remainder);
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.outbind;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SystemId)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(Password)));
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Request/SmppQuerySm.cs b/Packet/Request/SmppQuerySm.cs
new file mode 100644
index 0000000..06c20ad
--- /dev/null
+++ b/Packet/Request/SmppQuerySm.cs
@@ -0,0 +1,119 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using RoaminSMPP.Packet;
+using System.Collections;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// This class defines a query_sm ESME originated Pdu.
+	/// </summary>
+	public class SmppQuerySm : MessageLcd6
+	{
+		private string _MessageId = string.Empty;
+		
+		/// <summary>
+		/// The ID of the message.
+		/// </summary>
+		public string MessageId
+		{
+			get
+			{
+				return _MessageId;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.Length <= MSG_LENGTH)
+					{
+						_MessageId = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Message ID must be <= " + MSG_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_MessageId = string.Empty;
+				}
+			}
+		}
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a query_sm Pdu.  Sets source address TON to international, source address 
+		/// NPI to ISDN, source address to "", and message ID to an empty string.
+		/// </summary>
+		public SmppQuerySm(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a new SmppQuerySm for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		public SmppQuerySm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.query_sm;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the query_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			MessageId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppReplaceSm.cs b/Packet/Request/SmppReplaceSm.cs
new file mode 100644
index 0000000..82030ad
--- /dev/null
+++ b/Packet/Request/SmppReplaceSm.cs
@@ -0,0 +1,253 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Pdu to replace a previously submitted short message that hasn't been delivered.
+	/// The match is based on the message_id and source addresses of the original message.
+	/// </summary>
+	public class SmppReplaceSm : MessageLcd4
+	{
+		#region private fields
+		
+		private string _MessageId = string.Empty;
+		private string _ScheduleDeliveryTime = string.Empty;
+		private string _ValidityPeriod = string.Empty;
+		private byte _SmDefaultMessageId = 0;
+		private object _ShortMessage = null;
+		private byte _SmLength = 0;
+		
+		#endregion private fields
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// SMSC message ID of the message to be replaced. This must be the message ID of the 
+		/// original message.
+		/// </summary>
+		public string MessageId
+		{
+			get 
+			{
+				return _MessageId; 
+			} 
+			set 
+			{
+				if(value != null)
+				{
+					if(value.Length <= MSG_LENGTH)
+					{
+						_MessageId = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Message ID must be <= " + MSG_LENGTH + " characters.");
+					}
+				}
+				else
+				{
+					_MessageId = string.Empty;
+				}
+			} 
+		}
+		
+		/// <summary>
+		/// New scheduled delivery time for the short message.  Set to null, if updating of the 
+		/// original scheduled delivery time is not desired.
+		/// </summary>
+		public string ScheduleDeliveryTime
+		{
+			get
+			{
+				return _ScheduleDeliveryTime;
+			}
+			set
+			{
+				if(value != null && value != string.Empty)
+				{
+					if(value.Length == DATE_TIME_LENGTH)
+					{
+						_ScheduleDeliveryTime = value;
+					}
+					else
+					{
+						throw new ArgumentException("Scheduled delivery time not in correct format.");
+					}
+				}
+				else
+				{
+					_ScheduleDeliveryTime = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// New expiration time for the short message. Set to null, if updating of the original 
+		/// expiration time is not required.
+		/// </summary>
+		public string ValidityPeriod
+		{
+			get
+			{
+				return _ValidityPeriod;
+			}
+			set
+			{
+				if(value != null && value != string.Empty)
+				{
+					if(value.Length == DATE_TIME_LENGTH)
+					{
+						_ValidityPeriod = value;
+					}
+					else
+					{
+						throw new ArgumentException("Validity period not in correct format.");
+					}
+				}
+				else
+				{
+					_ValidityPeriod = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// New pre-defined(canned)message identifier.  Set to 0 if not using.
+		/// </summary>
+		public byte SmDefaultMessageId
+		{
+			get
+			{
+				return _SmDefaultMessageId;
+			}
+			set
+			{
+				_SmDefaultMessageId = value;
+			}
+		}
+		
+		/// <summary>
+		/// New short message to replace existing message.
+		/// </summary>
+		public object ShortMessage
+		{
+			get
+			{
+				return _ShortMessage;
+			}
+			set
+			{
+				_ShortMessage = value;
+			}
+		}
+		
+		/// <summary>
+		/// The length of the short message.
+		/// </summary>
+		public byte SmLength
+		{
+			get
+			{
+				return _SmLength;
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a replace_sm Pdu.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none,
+		/// message ID, scheduled delivery time, validity period, and short message to 
+		/// empty strings(NULL SMSC value).  Sets the default message ID to 0.
+		/// </summary>
+		public SmppReplaceSm(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a replace_sm Pdu.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none,
+		/// message ID, scheduled delivery time, validity period, and short message to 
+		/// empty strings(NULL SMSC value).  Sets the default message ID to 0.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes from an ESME.</param>
+		public SmppReplaceSm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.replace_sm;
+		}
+		
+		/// <summary>
+		/// Generates the hex encoded bytes for a replace_sm Pdu.
+		/// </summary>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ScheduleDeliveryTime)));	
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ValidityPeriod)));
+			pdu.Add((byte)RegisteredDelivery);
+			pdu.Add(_SmDefaultMessageId);
+			
+			_SmLength = PduUtil.InsertShortMessage(pdu, ShortMessage);
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the submit_sm Pdu.  The Pdu has basically the same format as
+		/// the submit_sm Pdu, but in this case it is a response.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			MessageId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			ScheduleDeliveryTime = SmppStringUtil.GetCStringFromBody(ref remainder);
+			ValidityPeriod = SmppStringUtil.GetCStringFromBody(ref remainder);
+			RegisteredDelivery =(RegisteredDeliveryType)remainder[0];
+			SmDefaultMessageId = remainder[1];
+			_SmLength = remainder[2];
+			ShortMessage = SmppStringUtil.GetStringFromBody(ref remainder, 3, 3 + _SmLength);
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppSubmitMulti.cs b/Packet/Request/SmppSubmitMulti.cs
new file mode 100644
index 0000000..d5cd7c8
--- /dev/null
+++ b/Packet/Request/SmppSubmitMulti.cs
@@ -0,0 +1,196 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Defines a submit_multi Pdu.
+	/// </summary>
+	public class SmppSubmitMulti : MessageLcd2
+	{
+		//note that all of the optional parameters are in the base class.
+		private byte _NumberOfDests = 0;
+		private DestinationAddress[] _DestinationAddresses = new DestinationAddress[0];
+		private const int MAX_DESTS = 254;
+		
+		#region properties
+		
+		/// <summary>
+		/// The number of destinations to send to.
+		/// </summary>
+		public byte NumberOfDestinations
+		{
+			get
+			{
+				return _NumberOfDests;
+			}
+		}
+		
+		/// <summary>
+		/// The destination addresses that will be sent to.  This will set the number of 
+		/// destination addresses as well.  Passing null in will set them to zero.  Calling the 
+		/// accessor will get you a cloned array.  You must use the mutator to modify the values.
+		/// </summary>
+		public DestinationAddress[] DestinationAddresses
+		{
+			get
+			{
+				return(DestinationAddress[])_DestinationAddresses.Clone();
+			}
+			set
+			{
+				_DestinationAddresses = (value == null) ? new DestinationAddress[0] : value;
+				_NumberOfDests = (byte)_DestinationAddresses.Length;
+			}
+		}
+		
+		#endregion properties
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a submit_multi Pdu.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none, 
+		/// ESM class to 0, data coding to SMSC default, protocol ID to v3.4, priority to level 1,
+		/// validity period to default, replace if present to false, default message ID to 0, 
+		/// the short message to an empty string, the number of destinations to 0 and the 
+		/// destination addresses to null.  Use the DestAddrFactory class to create 
+		/// destination addresses.
+		/// </summary>
+		public SmppSubmitMulti(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a submit_multi Pdu.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none, 
+		/// ESM class to 0, data coding to SMSC default, protocol ID to v3.4, priority to level 1,
+		/// validity period to default, replace if present to false, default message ID to 0, 
+		/// the short message to an empty string, the number of destinations to 0 and the 
+		/// destination addresses to null.  Use the DestAddrFactory class to create 
+		/// destination addresses.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes from an ESME</param>
+		public SmppSubmitMulti(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.submit_multi;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ServiceType)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			//number of destinations.
+			pdu.Add(NumberOfDestinations);
+			
+			//and their addresses
+			foreach(DestinationAddress address in _DestinationAddresses)
+			{
+				if(!address.IsDistributionList)
+				{
+					//pack up the byte array for this address
+					ArrayList sme = new ArrayList();
+					pdu.Add((byte)0x01);
+					pdu.Add((byte)address.DestinationAddressTon);
+					pdu.Add((byte)address.DestinationAddressNpi);
+					pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(
+						Encoding.ASCII.GetBytes(address.DestAddress)));
+				}
+				else
+				{
+					ArrayList dln = new ArrayList();
+					pdu.Add((byte)0x02);
+					pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(
+						Encoding.ASCII.GetBytes(address.DistributionList)));
+				}
+			}
+			
+			pdu.AddRange(base.GetBytesAfterDestination());
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// Decodes the submit_multi response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			
+			ServiceType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			
+			//the SMSC might not send back the number of destinations,
+			//so check if it did
+			if(remainder.Length > 0)
+			{
+				_NumberOfDests = remainder[0];
+				DestinationAddresses = new DestinationAddress[NumberOfDestinations];
+				
+				//trim off the number of destinations
+				long length = remainder.Length - 1;
+				byte[] newRemainder = new byte[length];
+				Array.Copy(remainder, 1, newRemainder, 0, length);
+				remainder = newRemainder;
+				newRemainder = null;
+				
+				for(int i = 0; i < _DestinationAddresses.Length; i++)
+				{
+					_DestinationAddresses[i] = new DestinationAddress(ref remainder);
+				}
+			}
+			
+			EsmClass = remainder[0];
+			ProtocolId =(SmppVersionType)remainder[1];
+			PriorityFlag =(PriorityType)remainder[2];
+			ScheduleDeliveryTime = SmppStringUtil.GetCStringFromBody(ref remainder, 3);
+			ValidityPeriod = SmppStringUtil.GetCStringFromBody(ref remainder);
+			RegisteredDelivery =(RegisteredDeliveryType)remainder[0];
+			ReplaceIfPresentFlag =(remainder[1] == 0)? false : true;
+			DataCoding =(DataCodingType)remainder[2];
+			SmDefaultMessageId = remainder[3];
+			_SmLength = remainder[4];
+			ShortMessage = SmppStringUtil.GetStringFromBody(ref remainder, 5, 5 + _SmLength);
+			
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppSubmitSm.cs b/Packet/Request/SmppSubmitSm.cs
new file mode 100644
index 0000000..f2cc333
--- /dev/null
+++ b/Packet/Request/SmppSubmitSm.cs
@@ -0,0 +1,346 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Defines an SMPP submit request.
+	/// </summary>
+	public class SmppSubmitSm : MessageLcd2
+	{
+		#region private fields
+
+		private TonType _DestinationAddressTon;
+		private NpiType _DestinationAddressNpi;
+		private string _DestinationAddress;
+		
+		#endregion private fields
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// Type of Number for destination.
+		/// </summary>
+		public TonType DestinationAddressTon
+		{
+			get
+			{
+				return _DestinationAddressTon;
+			}
+			set
+			{
+				_DestinationAddressTon = value;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator for destination.
+		/// </summary>
+		public NpiType DestinationAddressNpi
+		{
+			get
+			{
+				return _DestinationAddressNpi;
+			}
+			set
+			{
+				_DestinationAddressNpi = value;
+			}
+		}
+		
+		/// <summary>
+		/// Destination address of this short message.  Null values will be converted to an
+		/// empty string.
+		/// </summary>
+		public string DestinationAddress
+		{
+			get
+			{
+				return _DestinationAddress;
+			}
+			set
+			{
+				if(value != null)
+				{
+					if(value.ToString().Length <= ADDRESS_LENGTH)
+					{
+						_DestinationAddress = value;
+					}
+					else
+					{
+						throw new ArgumentOutOfRangeException(
+							"Destination Address too long(must be <= "+ ADDRESS_LENGTH + " 20 characters).");
+					}
+				}
+				else
+				{
+					_DestinationAddress = string.Empty;
+				}
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region optional params
+		
+		/// <summary>
+		/// Indicates to the SMSC that there are further messages for the same destination.
+		/// </summary>
+		public bool MoreMessagesToSend
+		{
+			get
+			{
+				byte[] bytes = GetOptionalParamBytes((ushort)OptionalParamCodes.more_messages_to_send);
+					
+				return(bytes[0] == 0)? false : true;
+			}
+			
+			set
+			{
+				byte sendMore;
+				if(value == false)
+				{
+					sendMore =(byte)0x00;
+				}
+				else
+				{
+					sendMore =(byte)0x01;
+				}
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.more_messages_to_send, new Byte[] {sendMore});
+			}
+		}
+		
+		/// <summary>
+		/// A response code set by the user in a User Acknowledgement/Reply message. The
+		/// response codes are application specific.  From the SMPP spec:
+		///
+		/// 0 to 255(IS-95 CDMA)
+		/// 0 to 15(CMT-136 TDMA)
+		/// </summary>
+		public byte UserResponseCode
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.user_response_code)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.user_response_code, new Byte[] {value});
+			}
+		}
+		
+		/// <summary>
+		/// Used to indicate the number of messages stored in a mailbox.
+		/// </summary>
+		public byte NumberOfMessages
+		{
+			get
+			{
+				return GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.number_of_messages)[0];
+			}
+			
+			set
+			{
+				const int MAX_NUM_MSGS = 99;
+				
+				if(value <= MAX_NUM_MSGS)
+				{
+					SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.number_of_messages, new Byte[] {value});
+				}
+				else
+				{
+					throw new ArgumentException(
+						"number_of_messages must be between 0 and " + MAX_NUM_MSGS + ".");
+				}
+			}
+		}
+		
+		/// <summary>
+		/// From the SMPP spec:
+		/// The its_reply_type parameter is a required parameter for the CDMA Interactive
+		/// Teleservice as defined by the Korean PCS carriers [KORITS]. It indicates and
+		/// controls the MS users reply method to an SMS delivery message received from
+		/// the ESME.
+		/// </summary>
+		public ItsReplyTypeType ItsReplyType
+		{
+			get
+			{
+				return (ItsReplyTypeType)GetOptionalParamBytes(
+					(ushort)OptionalParamCodes.its_reply_type)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(ushort)Pdu.OptionalParamCodes.its_reply_type, new Byte[] {(byte)value});
+			}
+		}
+		
+		/// <summary>
+		/// From the SMPP spec:
+		/// The its_session_info parameter is a required parameter for the CDMA Interactive
+		/// Teleservice as defined by the Korean PCS carriers [KORITS]. It contains control
+		/// information for the interactive session between an MS and an ESME.
+		///
+		/// See section 5.3.2.43 of the SMPP spec for how to set this.
+		/// </summary>
+		public string ItsSessionInfo
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.its_session_info);
+			}
+			
+			set
+			{
+				PduUtil.SetItsSessionInfo(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// From the SMPP spec:
+		/// The ussd_service_op parameter is required to define the USSD service operation
+		/// when SMPP is being used as an interface to a(GSM)USSD system.
+		///
+		/// See 5.3.2.44 of the SMPP spec for how to set this.
+		/// </summary>
+		public string UssdServiceOp
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)OptionalParamCodes.ussd_service_op);
+			}
+			
+			set
+			{
+				if(value == null)
+				{
+					SetOptionalParamString(
+						(ushort)Pdu.OptionalParamCodes.ussd_service_op, string.Empty);
+				}
+				else if(value.Length == 1)
+				{
+					SetOptionalParamString(
+						(ushort)Pdu.OptionalParamCodes.ussd_service_op, value);
+				}
+				else
+				{
+					throw new ArgumentException("ussd_service_op must have length 1");
+				}
+			}
+		}
+		
+		#endregion optional params
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a submit Pdu.  Sets source address TON to international, 
+		/// source address NPI to ISDN, source address to "", registered delivery type to none, 
+		/// ESM class to 0, data coding to SMSC default, protocol ID to v3.4, priority to level 1,
+		/// validity period to default, replace if present to false, default message ID to 0, 
+		/// the short message to an empty string, the destination address TON to international, 
+		/// destination address NPI to ISDN, the destination address to "", the command status 
+		/// to 0, and the Command ID to submit_sm.
+		/// </summary>
+		public SmppSubmitSm(): base()
+		{
+		}
+		
+		/// <summary>
+		/// Creates a new SmppSubmitSm for incoming PDUs.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes to decode.</param>
+		public SmppSubmitSm(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			DestinationAddressTon = Pdu.TonType.International;
+			DestinationAddressNpi = Pdu.NpiType.ISDN;
+			DestinationAddress = null;
+			CommandStatus = 0;
+			CommandID = CommandIdType.submit_sm;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(ServiceType)));
+			pdu.Add((byte)SourceAddressTon);
+			pdu.Add((byte)SourceAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SourceAddress)));
+			pdu.Add((byte)DestinationAddressTon);
+			pdu.Add((byte)DestinationAddressNpi);
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(DestinationAddress)));
+			pdu.AddRange(GetBytesAfterDestination());
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the submit_sm Pdu.  The Pdu has basically the same format as
+		/// the submit_sm Pdu, but in this case it is a response.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			ServiceType = SmppStringUtil.GetCStringFromBody(ref remainder);
+			SourceAddressTon =(TonType)remainder[0];
+			SourceAddressNpi =(NpiType)remainder[1];
+			SourceAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			DestinationAddressTon =(TonType)remainder[0];
+			DestinationAddressNpi =(NpiType)remainder[1];
+			DestinationAddress = SmppStringUtil.GetCStringFromBody(ref remainder, 2);
+			EsmClass = remainder[0];
+			ProtocolId =(SmppVersionType)remainder[1];
+			PriorityFlag =(PriorityType)remainder[2];
+			ScheduleDeliveryTime = SmppStringUtil.GetCStringFromBody(ref remainder, 3);
+			ValidityPeriod = SmppStringUtil.GetCStringFromBody(ref remainder);
+			RegisteredDelivery =(RegisteredDeliveryType)remainder[0];
+			ReplaceIfPresentFlag =(remainder[1] == 0)? false : true;
+			DataCoding =(DataCodingType)remainder[2];
+			SmDefaultMessageId = remainder[3];
+			_SmLength = remainder[4];
+			ShortMessage = SmppStringUtil.GetStringFromBody(ref remainder, 5, 5 + _SmLength);
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Request/SmppUnbind.cs b/Packet/Request/SmppUnbind.cs
new file mode 100644
index 0000000..633bdd3
--- /dev/null
+++ b/Packet/Request/SmppUnbind.cs
@@ -0,0 +1,76 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Request
+{
+	/// <summary>
+	/// Class to issue an unbind request to the SMSC.
+	/// </summary>
+	public class SmppUnbind : Pdu
+	{	
+		#region constructors
+		
+		/// <summary>
+		/// Creates an unbind PDU.
+		/// </summary>
+		public SmppUnbind(): base()
+		{}
+		
+		/// <summary>
+		/// Creates an unbind PDU.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppUnbind(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.unbind;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// This decodes the query_sm Pdu.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			
+			TranslateTlvDataIntoTable(remainder);
+		}
+	}
+}
diff --git a/Packet/Response/SmppBindResp.cs b/Packet/Response/SmppBindResp.cs
new file mode 100644
index 0000000..753e758
--- /dev/null
+++ b/Packet/Response/SmppBindResp.cs
@@ -0,0 +1,124 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Text;
+using System.Collections;
+using RoaminSMPP;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Class to define an SMSC bind response.
+	/// </summary>
+	public class SmppBindResp : Pdu
+	{
+		private string _SystemId = string.Empty;
+		
+		/// <summary>
+		/// The ID of the SMSC.
+		/// </summary>
+		public string SystemId
+		{
+			get
+			{
+				return _SystemId;
+			}
+			
+			set
+			{
+				_SystemId = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// The SMPP version supported by SMSC.
+		/// </summary>
+		public string ScInterfaceVersion
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)
+					Pdu.OptionalParamCodes.SC_interface_version);
+			}
+			
+			set
+			{
+				string version = value;
+				if(value == null)
+				{
+					version = string.Empty;
+				}
+				SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.SC_interface_version, version);
+			}
+		}
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a bind response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppBindResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a bind_resp.
+		/// </summary>
+		public SmppBindResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the bind response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			SystemId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.  Note that this sets the bind type to 
+		/// transceiver so you will want to change this if you are not dealing with a 
+		/// transceiver.  This also sets system type to an empty string.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.bind_transceiver_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(SystemId)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppCancelSmResp.cs b/Packet/Response/SmppCancelSmResp.cs
new file mode 100644
index 0000000..a1ab132
--- /dev/null
+++ b/Packet/Response/SmppCancelSmResp.cs
@@ -0,0 +1,75 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Packet;
+	
+namespace RoaminSMPP.Packet.Response
+{	
+	/// <summary>
+	/// Response Pdu for the cancel_sm command.
+	/// </summary>
+	public class SmppCancelSmResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates a cancel_sm Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppCancelSmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a cancel_sm Pdu.
+		/// </summary>
+		public SmppCancelSmResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the cancel_sm response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			TranslateTlvDataIntoTable(BytesAfterHeader);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.cancel_sm_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppDataSmResp.cs b/Packet/Response/SmppDataSmResp.cs
new file mode 100644
index 0000000..6365674
--- /dev/null
+++ b/Packet/Response/SmppDataSmResp.cs
@@ -0,0 +1,189 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Utility;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Response Pdu for the data_sm command.
+	/// </summary>
+	public class SmppDataSmResp : SmppSubmitSmResp
+	{
+		/// <summary>
+		/// Enumerates the delivery failure types.
+		/// </summary>
+		public enum DeliveryFailureType : byte
+		{
+			/// <summary>
+			/// DestinationUnavailable
+			/// </summary>
+			DestinationUnavailable = 0x00,
+			/// <summary>
+			/// DestinationAddressInvalid
+			/// </summary>
+			DestinationAddressInvalid = 0x01,
+			/// <summary>
+			/// PermanentNetworkError
+			/// </summary>
+			PermanentNetworkError = 0x02,
+			/// <summary>
+			/// TemporaryNetworkError
+			/// </summary>
+			TemporaryNetworkError = 0x03
+		}
+		
+		#region optional parameters
+		
+		/// <summary>
+		/// Indicates the reason for delivery failure.
+		/// </summary>
+		public DeliveryFailureType DeliveryFailureReason
+		{
+			get
+			{
+				return(DeliveryFailureType)
+					GetOptionalParamBytes((ushort)
+					Pdu.OptionalParamCodes.delivery_failure_reason)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(UInt16)Pdu.OptionalParamCodes.delivery_failure_reason,
+					BitConverter.GetBytes(
+					UnsignedNumConverter.SwapByteOrdering((byte)value)));
+			}
+		}
+		
+		/// <summary>
+		/// Error code specific to a wireless network.  See SMPP spec section
+		/// 5.3.2.31 for details.
+		/// </summary>
+		public string NetworkErrorCode
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)
+					Pdu.OptionalParamCodes.network_error_code);
+			}
+			
+			set
+			{
+				PduUtil.SetNetworkErrorCode(this, value);
+			}
+		}
+		
+		/// <summary>
+		/// Text(ASCII)giving additional info on the meaning of the response.
+		/// </summary>
+		public string AdditionalStatusInfoText
+		{
+			get
+			{
+				return GetOptionalParamString((ushort)
+					Pdu.OptionalParamCodes.additional_status_info_text);
+			}
+			
+			set
+			{
+				const int MAX_STATUS_LEN = 264;
+				if(value == null)
+				{
+					SetOptionalParamString(
+						(ushort)Pdu.OptionalParamCodes.additional_status_info_text, string.Empty);
+				}
+				else if(value.Length <= MAX_STATUS_LEN)
+				{
+					SetOptionalParamString(
+						(ushort)Pdu.OptionalParamCodes.additional_status_info_text, value);
+				}
+				else
+				{
+					throw new ArgumentException(
+						"additional_status_info_text must have length <= " + MAX_STATUS_LEN);
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Indicates whether the Delivery Pending Flag was set.
+		/// </summary>
+		public DpfResultType DpfResult
+		{
+			get
+			{
+				return(DpfResultType)
+					GetOptionalParamBytes((ushort)
+					Pdu.OptionalParamCodes.dpf_result)[0];
+			}
+			
+			set
+			{
+				SetOptionalParamBytes(
+					(UInt16)Pdu.OptionalParamCodes.dpf_result,
+					BitConverter.GetBytes(
+					UnsignedNumConverter.SwapByteOrdering((byte)value)));
+			}
+		}
+		
+		#endregion optional parameters
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a data_sm_resp Pdu.
+		/// </summary>
+		public SmppDataSmResp(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a data_sm_resp Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppDataSmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.data_sm_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppDeliverSmResp.cs b/Packet/Response/SmppDeliverSmResp.cs
new file mode 100644
index 0000000..3854c36
--- /dev/null
+++ b/Packet/Response/SmppDeliverSmResp.cs
@@ -0,0 +1,78 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// This class defines an ESME originated deliver_sm_resp.
+	/// </summary>
+	public class SmppDeliverSmResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates a deliver_sm_resp Pdu.  Sets command status and command ID.
+		/// </summary>
+		public SmppDeliverSmResp(): base()
+		{}
+		
+		/// <summary>
+		/// Creates a deliver_sm_resp Pdu.  Sets command status and command ID.
+		/// </summary>
+		/// <param name="incomingBytes">The incoming bytes from the ESME.</param>
+		public SmppDeliverSmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.deliver_sm_resp;
+		}
+		
+		/// <summary>
+		/// Creates the byte encoding for this Pdu.
+		/// </summary>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			//the message_id is unused and is always set to null
+			pdu.Add((byte)0x00);
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+		
+		/// <summary>
+		/// Decodes the deliver_sm response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder, 1);
+		}
+	}
+}
diff --git a/Packet/Response/SmppEnquireLinkResp.cs b/Packet/Response/SmppEnquireLinkResp.cs
new file mode 100644
index 0000000..77ddbaa
--- /dev/null
+++ b/Packet/Response/SmppEnquireLinkResp.cs
@@ -0,0 +1,75 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Packet;
+	
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Defines the response Pdu from an enquire_link.
+	/// </summary>
+	public class SmppEnquireLinkResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates an enquire_link Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppEnquireLinkResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates an enquire_link Pdu.
+		/// </summary>
+		public SmppEnquireLinkResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the enquire_link response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			TranslateTlvDataIntoTable(BytesAfterHeader);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.enquire_link_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppGenericNackResp.cs b/Packet/Response/SmppGenericNackResp.cs
new file mode 100644
index 0000000..22236c8
--- /dev/null
+++ b/Packet/Response/SmppGenericNackResp.cs
@@ -0,0 +1,78 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Represents a generic NACK sent by the SMSC.
+	/// </summary>
+	public class SmppGenericNackResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates a generic_nack response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppGenericNackResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a generic_nack response Pdu.
+		/// </summary>
+		public SmppGenericNackResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the generic NACK response from the SMSC.  Since a generic
+		/// NACK response contains essentially nothing other than the header,
+		/// this method does nothing special.  It will grab any TLVs that are in
+		/// the Pdu, however.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			TranslateTlvDataIntoTable(BytesAfterHeader);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.generic_nack;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppQuerySmResp.cs b/Packet/Response/SmppQuerySmResp.cs
new file mode 100644
index 0000000..00a401d
--- /dev/null
+++ b/Packet/Response/SmppQuerySmResp.cs
@@ -0,0 +1,175 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// This class defines the response to a query_sm Pdu.
+	/// </summary>
+	public class SmppQuerySmResp : Pdu
+	{
+		private string _MessageId = string.Empty;
+		private string _FinalDate = string.Empty;
+		private MessageStateType _MessageStatus = MessageStateType.Enroute;
+		private byte _ErrorCode = 0;
+		
+		#region mandatory parameters
+		
+		/// <summary>
+		/// SMSC Message ID of the message whose state is being queried.
+		/// </summary>
+		public string MessageId
+		{
+			get
+			{
+				return _MessageId;
+			}
+			
+			set
+			{
+				_MessageId = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Date and time when the queried message reached a final state. For messages
+		/// which have not yet reached a final state this field will be null.
+		/// </summary>
+		public string FinalDate
+		{
+			get
+			{
+				return _FinalDate;
+			}
+			
+			set
+			{
+				if(value != null && value != string.Empty)
+				{
+					if(value.Length == DATE_TIME_LENGTH)
+					{
+						_FinalDate = value;
+					}
+					else
+					{
+						throw new ArgumentException("Final date is not in the correct format.");
+					}
+				}
+				else
+				{
+					_FinalDate = string.Empty;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Specifies the status of the queried short message.
+		/// </summary>
+		public MessageStateType MessageStatus
+		{
+			get
+			{
+				return _MessageStatus;
+			}
+			
+			set
+			{
+				_MessageStatus = value;
+			}
+		}
+		
+		/// <summary>
+		/// Holds a network error code defining the reason for failure of message delivery.
+		/// </summary>
+		public byte ErrorCode
+		{
+			get
+			{
+				return _ErrorCode;
+			}
+			
+			set
+			{
+				_ErrorCode = value;
+			}
+		}
+		
+		#endregion mandatory parameters
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a query_sm response.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppQuerySmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a query_sm response.
+		/// </summary>
+		public SmppQuerySmResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the query_sm response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			byte[] remainder = BytesAfterHeader;
+			MessageId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			FinalDate = SmppStringUtil.GetCStringFromBody(ref remainder);
+			MessageStatus = (MessageStateType)remainder[0];
+			ErrorCode = remainder[1];
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder, 2);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.query_sm_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(FinalDate)));
+			pdu.Add((byte)MessageStatus);
+			pdu.Add(ErrorCode);
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppReplaceSmResp.cs b/Packet/Response/SmppReplaceSmResp.cs
new file mode 100644
index 0000000..4290b03
--- /dev/null
+++ b/Packet/Response/SmppReplaceSmResp.cs
@@ -0,0 +1,75 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP.Packet;
+	
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Defines the replace_sm_resp Pdu.
+	/// </summary>
+	public class SmppReplaceSmResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates a replace_sm response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppReplaceSmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a replace_sm response Pdu.
+		/// </summary>
+		public SmppReplaceSmResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the replace_sm response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			TranslateTlvDataIntoTable(BytesAfterHeader);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.replace_sm_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppSubmitMultiResp.cs b/Packet/Response/SmppSubmitMultiResp.cs
new file mode 100644
index 0000000..9b4331e
--- /dev/null
+++ b/Packet/Response/SmppSubmitMultiResp.cs
@@ -0,0 +1,145 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Description of SmppSubmitMultiResp.
+	/// </summary>
+	public class SmppSubmitMultiResp : SmppSubmitSmResp
+	{
+		private byte _NumberUnsuccessful = 0;
+		private UnsuccessAddress[] _UnsuccessfulAddresses = new UnsuccessAddress[0];
+		
+		/// <summary>
+		/// The number of messages that could not be delivered.  The mutator is not 
+		/// provided as setting the unsucess addresses will set it.
+		/// </summary>
+		public byte NumberUnsuccessful
+		{
+			get
+			{
+				return _NumberUnsuccessful;
+			}
+		}
+		
+		/// <summary>
+		/// The array of unsuccessful addresses.  This will set the number of addresses as well.  
+		/// Passing in null will set them to zero.  Calling the accessor will get you a cloned array.  
+		/// You must use the set accessor to modify the values.
+		/// </summary>
+		public UnsuccessAddress[] UnsuccessfulAddresses
+		{
+			get
+			{
+				return(UnsuccessAddress[])_UnsuccessfulAddresses.Clone();
+			}
+			
+			set
+			{
+				_UnsuccessfulAddresses = (value == null) ? new UnsuccessAddress[0] : value;
+				_NumberUnsuccessful = (byte)_UnsuccessfulAddresses.Length;
+			}
+		}
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a submit_multi response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppSubmitMultiResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a submit_multi response Pdu.
+		/// </summary>
+		public SmppSubmitMultiResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the submit_multi response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			DecodeNonTlv();
+			
+			byte[] remainder = base.ResponseAfterMsgId;
+			//the SMSC might not send back the number of unsuccessful messages,
+			//so check if it did
+			if(remainder.Length > 0)
+			{
+				_NumberUnsuccessful = remainder[0];
+				UnsuccessfulAddresses = new UnsuccessAddress[NumberUnsuccessful];
+				long length = remainder.Length - 1;
+				byte[] newRemainder = new byte[length];
+				Array.Copy(remainder, 1, newRemainder, 0, length);
+				remainder = newRemainder;
+				newRemainder = null;
+				//unsuccessful
+				for(int i = 0; i < UnsuccessfulAddresses.Length; i++)
+				{
+					_UnsuccessfulAddresses[i] = new UnsuccessAddress(ref remainder);
+				}
+			}
+			
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(remainder);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.submit_multi_resp;
+		}
+		
+		/// <summary>
+		/// Creates the byte encoding for this Pdu.
+		/// </summary>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			pdu.Add(NumberUnsuccessful);
+			//add the unsuccess addresses
+			UnsuccessAddress[] unsuccessfulAddresses = UnsuccessfulAddresses;
+			
+			for(int i = 0; i < NumberUnsuccessful; i++)
+			{
+				pdu.Add((byte)unsuccessfulAddresses[i].DestinationAddressTon);
+				pdu.Add((byte)unsuccessfulAddresses[i].DestinationAddressNpi);
+				pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(
+					Encoding.ASCII.GetBytes(unsuccessfulAddresses[i].DestinationAddress)));
+				pdu.AddRange(BitConverter.GetBytes(
+					UnsignedNumConverter.SwapByteOrdering(unsuccessfulAddresses[i].ErrorStatusCode)));
+			}
+//
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppSubmitSmResp.cs b/Packet/Response/SmppSubmitSmResp.cs
new file mode 100644
index 0000000..4ce4db6
--- /dev/null
+++ b/Packet/Response/SmppSubmitSmResp.cs
@@ -0,0 +1,123 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Utility;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Defines the submit_sm response from the SMSC.
+	/// </summary>
+	public class SmppSubmitSmResp : Pdu
+	{
+		private string _MessageId = string.Empty;
+		private byte[] _ResponseAfterMsgId;
+		
+		/// <summary>
+		/// The message ID(SMSC-assigned)of the submitted message.
+		/// </summary>
+		public string MessageId
+		{
+			get
+			{
+				return _MessageId;
+			}
+			
+			set
+			{
+				_MessageId = (value == null) ? string.Empty : value;
+			}
+		}
+		
+		/// <summary>
+		/// Accessor for the submit_multi to get at the response after the message ID.
+		/// This is, in essence, set only after DecodeSmscResponse()in this base class
+		/// is called.
+		/// </summary>
+		protected byte[] ResponseAfterMsgId
+		{
+			get
+			{
+				return _ResponseAfterMsgId;
+			}
+		}
+		
+		#region constructors
+		
+		/// <summary>
+		/// Creates a submit_sm response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppSubmitSmResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates a submit_sm_resp
+		/// </summary>
+		public SmppSubmitSmResp(): base()
+		{
+		}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the submit response from the SMSC.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			DecodeNonTlv();
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(_ResponseAfterMsgId);
+		}
+		
+		/// <summary>
+		/// Decodes the non-TLV bytes.  Needed for the submit_multi_resp.
+		/// </summary>
+		protected void DecodeNonTlv()
+		{
+			//header
+			byte[] remainder = BytesAfterHeader;
+			MessageId = SmppStringUtil.GetCStringFromBody(ref remainder);
+			_ResponseAfterMsgId = remainder;
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.submit_sm_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			pdu.AddRange(SmppStringUtil.ArrayCopyWithNull(Encoding.ASCII.GetBytes(MessageId)));
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/Packet/Response/SmppUnbindResp.cs b/Packet/Response/SmppUnbindResp.cs
new file mode 100644
index 0000000..4a6015d
--- /dev/null
+++ b/Packet/Response/SmppUnbindResp.cs
@@ -0,0 +1,77 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+
+namespace RoaminSMPP.Packet.Response
+{
+	/// <summary>
+	/// Defines the unbind response from the SMSC.
+	/// </summary>
+	public class SmppUnbindResp : Pdu
+	{
+		#region constructors
+		
+		/// <summary>
+		/// Creates an unbind response Pdu.
+		/// </summary>
+		/// <param name="incomingBytes">The bytes received from an ESME.</param>
+		public SmppUnbindResp(byte[] incomingBytes): base(incomingBytes)
+		{}
+		
+		/// <summary>
+		/// Creates an unbind response Pdu.
+		/// </summary>
+		public SmppUnbindResp(): base()
+		{}
+		
+		#endregion constructors
+		
+		/// <summary>
+		/// Decodes the unbind response from the SMSC.  Since an unbind response contains
+		/// essentially nothing other than the header, this method does nothing special.
+		/// It will grab any TLVs that are in the Pdu, however.
+		/// </summary>
+		protected override void DecodeSmscResponse()
+		{
+			//fill the TLV table if applicable
+			TranslateTlvDataIntoTable(BytesAfterHeader);
+		}
+		
+		/// <summary>
+		/// Initializes this Pdu for sending purposes.
+		/// </summary>
+		protected override void InitPdu()
+		{
+			base.InitPdu();
+			CommandStatus = 0;
+			CommandID = CommandIdType.unbind_resp;
+		}
+		
+		///<summary>
+		/// Gets the hex encoding(big-endian)of this Pdu.
+		///</summary>
+		///<return>The hex-encoded version of the Pdu</return>
+		public override void ToMsbHexEncoding()
+		{
+			ArrayList pdu = GetPduHeader();
+			
+			PacketBytes = EncodePduForTransmission(pdu);
+		}
+	}
+}
diff --git a/README.TXT b/README.TXT
new file mode 100644
index 0000000..5217f78
--- /dev/null
+++ b/README.TXT
@@ -0,0 +1,12 @@
+This software is meant to provide an open source edition of the basic 
+SMPP v3.4 functionality.  It includes PDU definitions for all of the
+PDUs in the spec.
+
+I will no longer be adding functionality to this app; I may or may not fix bugs.  If you find a 
+bug and want it fixed, BE NICE!  I don't like people who make demands on my (not so free) time.
+
+Please read the enclosed license files, COPYING (GNU GPL) and COPYING.LESSER (GNU LGPL) for more details.
+
+Thanks!
+
+-Chris Bouzek
diff --git a/RoaminSMPP.cmbx b/RoaminSMPP.cmbx
new file mode 100644
index 0000000..d4c6284
--- /dev/null
+++ b/RoaminSMPP.cmbx
@@ -0,0 +1,16 @@
+<Combine fileversion="1.0" name="RoaminSMPP" description="">
+  <StartMode startupentry="RoaminSMPP" single="True">
+    <Execute entry="RoaminSMPP" type="None" />
+  </StartMode>
+  <Entries>
+    <Entry filename=".\RoaminSMPP.prjx" />
+  </Entries>
+  <Configurations active="Debug">
+    <Configuration name="Release">
+      <Entry name="RoaminSMPP" configurationname="Debug" build="False" />
+    </Configuration>
+    <Configuration name="Debug">
+      <Entry name="RoaminSMPP" configurationname="Debug" build="False" />
+    </Configuration>
+  </Configurations>
+</Combine>
\ No newline at end of file
diff --git a/RoaminSMPP.mdsx b/RoaminSMPP.mdsx
new file mode 100644
index 0000000..0bb9bbf
--- /dev/null
+++ b/RoaminSMPP.mdsx
@@ -0,0 +1,3 @@
+<MonoDevelopSolution fileversion="1.0">
+  <RelativeOutputPath>./build/bin</RelativeOutputPath>
+</MonoDevelopSolution>
\ No newline at end of file
diff --git a/RoaminSMPP.pidb b/RoaminSMPP.pidb
new file mode 100644
index 0000000..bf53c53
Binary files /dev/null and b/RoaminSMPP.pidb differ
diff --git a/RoaminSMPP.prjx b/RoaminSMPP.prjx
new file mode 100644
index 0000000..2ba3426
--- /dev/null
+++ b/RoaminSMPP.prjx
@@ -0,0 +1,92 @@
+<Project name="RoaminSMPP" standardNamespace="RoaminSMPP" description="" newfilesearch="None" enableviewstate="True" version="1.1" projecttype="C#">
+  <Contents>
+    <File name=".\AssemblyInfo.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppUnbindResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppBindResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppOutbind.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppSubmitSmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppSubmitMultiResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppDeliverSm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppQuerySmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppCancelSmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppReplaceSmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppEnquireLinkResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppAlertNotification.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppDataSmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppGenericNackResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response\SmppDeliverSmResp.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet" subtype="Directory" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Pdu.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Response" subtype="Directory" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request" subtype="Directory" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppReplaceSm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\MessageLcd3.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\MessageLcd4.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\MessageLcd6.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppBind.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppCancelSm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppDataSm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppEnquireLink.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppGenericNack.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppQuerySm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\MessageLcd2.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppSubmitMulti.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppSubmitSm.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Packet\Request\SmppUnbind.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility" subtype="Directory" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\DestinationAddress.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\PduFactory.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\SmppStringUtil.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\TlvTable.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\UnsignedNumConverter.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\UnsuccessAddress.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\Utility\PduUtil.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\SMPPCommunicator.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\ASyncSocketClient.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject" subtype="Directory" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\UnbindRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\BindEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\BindRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\CancelEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\CancelSmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\CancelSmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\CommonErrorEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\DataSmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\DataSmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\DeliverSmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\DeliverSmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\EnquireLinkEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\EnquireLinkRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\GenericNackEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\QuerySmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\QuerySmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\ReplaceSmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\ReplaceSmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\SmppEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\SubmitMultiEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\SubmitMultiRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\SubmitSmEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\SubmitSmRespEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\UnbindEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name=".\EventObject\AlertEventArgs.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+  </Contents>
+  <References />
+  <DeploymentInformation target="" script="" strategy="File" />
+  <Configuration runwithwarnings="True" name="Debug">
+    <CodeGeneration runtime="MsNet" compiler="Csc" compilerversion="v1.1.4322" warninglevel="4" nowarn="" includedebuginformation="True" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Library" definesymbols="DEBUG; TRACE" generatexmldocumentation="True" win32Icon="" noconfig="False" nostdlib="False" />
+    <Execution commandlineparameters="" consolepause="True" />
+    <Output directory=".\bin\Debug" assembly="RoaminSMPP" executeScript="" executeBeforeBuild="" executeAfterBuild="" executeBeforeBuildArguments="" executeAfterBuildArguments="" />
+  </Configuration>
+  <Configurations active="Debug">
+    <Configuration runwithwarnings="True" name="Debug">
+      <CodeGeneration runtime="MsNet" compiler="Csc" compilerversion="v1.1.4322" warninglevel="4" nowarn="" includedebuginformation="True" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Library" definesymbols="DEBUG; TRACE" generatexmldocumentation="True" win32Icon="" noconfig="False" nostdlib="False" />
+      <Execution commandlineparameters="" consolepause="True" />
+      <Output directory=".\bin\Debug" assembly="RoaminSMPP" executeScript="" executeBeforeBuild="" executeAfterBuild="" executeBeforeBuildArguments="" executeAfterBuildArguments="" />
+    </Configuration>
+    <Configuration runwithwarnings="True" name="Release">
+      <CodeGeneration runtime="MsNet" compiler="Csc" compilerversion="v1.1.4322" warninglevel="4" nowarn="" includedebuginformation="False" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Library" definesymbols="TRACE" generatexmldocumentation="True" win32Icon="" noconfig="False" nostdlib="False" />
+      <Execution commandlineparameters="" consolepause="True" />
+      <Output directory=".\bin\Release" assembly="RoaminSMPP" executeScript="" executeBeforeBuild="" executeAfterBuild="" executeBeforeBuildArguments="" executeAfterBuildArguments="" />
+    </Configuration>
+  </Configurations>
+</Project>
\ No newline at end of file
diff --git a/SMPPCommunicator.cs b/SMPPCommunicator.cs
new file mode 100644
index 0000000..56ca12e
--- /dev/null
+++ b/SMPPCommunicator.cs
@@ -0,0 +1,1052 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Net.Sockets;
+using System.Collections;
+using System.Threading;
+using RoaminSMPP.Packet.Request;
+using RoaminSMPP.Utility;
+using RoaminSMPP.Packet.Response;
+using RoaminSMPP.Packet;
+using RoaminSMPP.EventObjects;
+using System.Timers;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace RoaminSMPP 
+{
+	/// <summary>
+	/// Wrapper class to provide asynchronous I/O for the RoaminSMPP library.  Note that most 
+	/// SMPP events have default handlers.  If the events are overridden by the caller by adding 
+	/// event handlers, it is the caller's responsibility to ensure that the proper response is 
+	/// sent.  For example: there is a default deliver_sm_resp implemented.  If you "listen" to 
+	/// the deliver_sm event, it is your responsibility to then send the deliver_sm_resp packet.
+	/// </summary>
+	public class SMPPCommunicator : Component
+	{
+		private AsyncSocketClient asClient;
+		private Int16 _Port;
+		private SmppBind.BindingType _BindType;
+		private string _Host;
+		private Pdu.NpiType _NpiType;
+		private Pdu.TonType _TonType; 
+		private SmppBind.SmppVersionType _Version;
+		private string _AddressRange;
+		private string _Password;
+		private string _SystemId;
+		private string _SystemType;
+		private System.Timers.Timer timer;
+		private int _EnquireLinkInterval;
+		private int _SleepTimeAfterSocketFailure;
+		private bool _SentUnbindPacket = true;  //default to true since we start out unbound
+		private string username;
+		
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		protected Container components = null;
+
+		#region properties
+		
+		/// <summary>
+		/// The username to use for software validation.
+		/// </summary>
+		public string Username
+		{
+			set
+			{
+				username = value;
+			}
+		}
+
+		/// <summary>
+		/// Accessor to determine if we have sent the unbind packet out.  Once the packet is 
+		/// sent, you can consider this object to be unbound.
+		/// </summary>
+		public bool SentUnbindPacket
+		{
+			get
+			{
+				return _SentUnbindPacket;
+			}
+		}
+		
+		/// <summary>
+		/// The port on the SMSC to connect to.
+		/// </summary>
+		public Int16 Port
+		{
+			get
+			{
+				return _Port;
+			}
+			set
+			{
+				_Port = value;
+			}
+		}
+		
+		/// <summary>
+		/// The binding type(receiver, transmitter, or transceiver)to use 
+		/// when connecting to the SMSC.
+		/// </summary>
+		public SmppBind.BindingType BindType
+		{
+			get
+			{
+				return _BindType;
+			}
+			set
+			{
+				_BindType = value;
+			}
+		
+		}
+		/// <summary>
+		/// The system type to use when connecting to the SMSC.
+		/// </summary>
+		public string SystemType
+		{
+			get
+			{
+				return _SystemType;
+			}
+			set
+			{
+				_SystemType = value;
+			}
+		}
+		/// <summary>
+		/// The system ID to use when connecting to the SMSC.  This is, 
+		/// in essence, a user name.
+		/// </summary>
+		public string SystemId
+		{
+			get
+			{
+				return _SystemId;
+			}
+			set
+			{
+				_SystemId = value;
+			}
+		}
+		/// <summary>
+		/// The password to use when connecting to an SMSC.
+		/// </summary>
+		public string Password
+		{
+			get
+			{
+				return _Password;
+			}
+			set
+			{
+				_Password = value;
+			}
+		}
+		
+		/// <summary>
+		/// The host to bind this SMPPCommunicator to.
+		/// </summary>
+		public string Host
+		{
+			get
+			{
+				return _Host;
+			}
+			set
+			{
+				_Host = value;
+			}
+		}
+		/// <summary>
+		/// The number plan indicator that this SMPPCommunicator should use.  
+		/// </summary>
+		public Pdu.NpiType NpiType 
+		{
+			get
+			{
+				return _NpiType;
+			}
+			set 
+			{
+				_NpiType = value;
+			}
+		}
+
+		/// <summary>
+		/// The type of number that this SMPPCommunicator should use.  
+		/// </summary>
+		public Pdu.TonType TonType 
+		{
+			get
+			{
+				return _TonType;
+			}
+			set 
+			{
+				_TonType = value;
+			}
+		}
+
+		/// <summary>
+		/// The SMPP specification version to use.
+		/// </summary>
+		public SmppBind.SmppVersionType Version 
+		{
+			get
+			{
+				return _Version;
+			}
+			set 
+			{
+				_Version = value;
+			}
+		}
+
+		/// <summary>
+		/// The address range of this SMPPCommunicator.
+		/// </summary>
+		public string AddressRange 
+		{
+			get
+			{
+				return _AddressRange;
+			}
+			set 
+			{
+				_AddressRange = value;
+			}
+		}
+
+		/// <summary>
+		/// Set to the number of seconds that should elapse in between enquire_link 
+		/// packets.  Setting this to anything other than 0 will enable the timer, setting 
+		/// it to 0 will disable the timer.  Note that the timer is only started/stopped 
+		/// during a bind/unbind.  Negative values are ignored.
+		/// </summary>
+		public int EnquireLinkInterval
+		{
+			get 
+			{
+				return _EnquireLinkInterval;
+			}
+
+			set
+			{
+				if(value >= 0)
+					_EnquireLinkInterval = value;
+			}
+		}
+
+		/// <summary>
+		/// Sets the number of seconds that the system will wait before trying to rebind 
+		/// after a total network failure(due to cable problems, etc).  Negative values are 
+		/// ignored.
+		/// </summary>
+		public int SleepTimeAfterSocketFailure
+		{
+			get 
+			{
+				return _SleepTimeAfterSocketFailure;
+			}
+
+			set
+			{
+				if(value >= 0)
+					_SleepTimeAfterSocketFailure = value;
+			}
+		}
+		#endregion properties
+		
+		#region events
+		/// <summary>
+		/// Event called when the communicator receives a bind response.
+		/// </summary>
+		public event BindRespEventHandler OnBindResp;
+		/// <summary>
+		/// Event called when an error occurs.
+		/// </summary>
+		public event ErrorEventHandler OnError;
+		/// <summary>
+		/// Event called when the communicator is unbound.
+		/// </summary>
+		public event UnbindRespEventHandler OnUnboundResp;
+		/// <summary>
+		/// Event called when the connection is closed.
+		/// </summary>
+		public event ClosingEventHandler OnClose;
+		/// <summary>
+		/// Event called when an alert_notification comes in.
+		/// </summary>
+		public event AlertEventHandler OnAlert;
+		/// <summary>
+		/// Event called when a submit_sm_resp is received.
+		/// </summary>
+		public event SubmitSmRespEventHandler OnSubmitSmResp;
+		/// <summary>
+		/// Event called when a response to an enquire_link_resp is received.
+		/// </summary>
+		public event EnquireLinkRespEventHandler OnEnquireLinkResp;
+		/// <summary>
+		/// Event called when a submit_sm is received.
+		/// </summary>
+		public event SubmitSmEventHandler OnSubmitSm;
+		/// <summary>
+		/// Event called when a query_sm is received.
+		/// </summary>
+		public event QuerySmEventHandler OnQuerySm;
+		/// <summary>
+		/// Event called when a generic_nack is received.
+		/// </summary>
+		public event GenericNackEventHandler OnGenericNack;
+		/// <summary>
+		/// Event called when an enquire_link is received.
+		/// </summary>
+		public event EnquireLinkEventHandler OnEnquireLink;
+		/// <summary>
+		/// Event called when an unbind is received.
+		/// </summary>
+		public event UnbindEventHandler OnUnbind;
+		/// <summary>
+		/// Event called when the communicator receives a request for a bind.
+		/// </summary>
+		public event BindEventHandler OnBind;
+		/// <summary>
+		/// Event called when the communicator receives a cancel_sm.
+		/// </summary>
+		public event CancelSmEventHandler OnCancelSm;
+		/// <summary>
+		/// Event called when the communicator receives a cancel_sm_resp.
+		/// </summary>
+		public event CancelSmRespEventHandler OnCancelSmResp;
+		/// <summary>
+		/// Event called when the communicator receives a query_sm_resp.
+		/// </summary>
+		public event QuerySmRespEventHandler OnQuerySmResp;
+		/// <summary>
+		/// Event called when the communicator receives a data_sm.
+		/// </summary>
+		public event DataSmEventHandler OnDataSm;
+		/// <summary>
+		/// Event called when the communicator receives a data_sm_resp.
+		/// </summary>
+		public event DataSmRespEventHandler OnDataSmResp;
+		/// <summary>
+		/// Event called when the communicator receives a deliver_sm.
+		/// </summary>
+		public event DeliverSmEventHandler OnDeliverSm;
+		/// <summary>
+		/// Event called when the communicator receives a deliver_sm_resp.
+		/// </summary>
+		public event DeliverSmRespEventHandler OnDeliverSmResp;
+		/// <summary>
+		/// Event called when the communicator receives a replace_sm.
+		/// </summary>
+		public event ReplaceSmEventHandler OnReplaceSm;
+		/// <summary>
+		/// Event called when the communicator receives a replace_sm_resp.
+		/// </summary>
+		public event ReplaceSmRespEventHandler OnReplaceSmResp;
+		/// <summary>
+		/// Event called when the communicator receives a submit_multi.
+		/// </summary>
+		public event SubmitMultiEventHandler OnSubmitMulti;
+		/// <summary>
+		/// Event called when the communicator receives a submit_multi_resp.
+		/// </summary>
+		public event SubmitMultiRespEventHandler OnSubmitMultiResp;
+		#endregion events
+		
+		#region delegates
+
+		/// <summary>
+		/// Delegate to handle binding responses of the communicator.
+		/// </summary>
+		public delegate void BindRespEventHandler(object source, BindRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle any errors that come up.
+		/// </summary>
+		public delegate void ErrorEventHandler(object source, CommonErrorEventArgs e);
+		/// <summary>
+		/// Delegate to handle the unbind_resp.
+		/// </summary>
+		public delegate void UnbindRespEventHandler(object source, UnbindRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle closing of the connection.
+		/// </summary>
+		public delegate void ClosingEventHandler(object source, EventArgs e);
+		/// <summary>
+		/// Delegate to handle alert_notification events.
+		/// </summary>
+		public delegate void AlertEventHandler(object source, AlertEventArgs e);
+		/// <summary>
+		/// Delegate to handle a submit_sm_resp
+		/// </summary>
+		public delegate void SubmitSmRespEventHandler(object source, SubmitSmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle the enquire_link response.
+		/// </summary>
+		public delegate void EnquireLinkRespEventHandler(object source, EnquireLinkRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle the submit_sm.
+		/// </summary>
+		public delegate void SubmitSmEventHandler(object source, SubmitSmEventArgs e);
+		/// <summary>
+		/// Delegate to handle the query_sm.
+		/// </summary>
+		public delegate void QuerySmEventHandler(object source, QuerySmEventArgs e);
+		/// <summary>
+		/// Delegate to handle generic_nack.
+		/// </summary>
+		public delegate void GenericNackEventHandler(object source, GenericNackEventArgs e);
+		/// <summary>
+		/// Delegate to handle the enquire_link.
+		/// </summary>
+		public delegate void EnquireLinkEventHandler(object source, EnquireLinkEventArgs e);
+		/// <summary>
+		/// Delegate to handle the unbind message.
+		/// </summary>
+		public delegate void UnbindEventHandler(object source, UnbindEventArgs e);
+		/// <summary>
+		/// Delegate to handle requests for binding of the communicator.
+		/// </summary>
+		public delegate void BindEventHandler(object source, BindEventArgs e);
+		/// <summary>
+		/// Delegate to handle cancel_sm.
+		/// </summary>
+		public delegate void CancelSmEventHandler(object source, CancelSmEventArgs e);
+		/// <summary>
+		/// Delegate to handle cancel_sm_resp.
+		/// </summary>
+		public delegate void CancelSmRespEventHandler(object source, CancelSmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle query_sm_resp.
+		/// </summary>
+		public delegate void QuerySmRespEventHandler(object source, QuerySmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle data_sm.
+		/// </summary>
+		public delegate void DataSmEventHandler(object source, DataSmEventArgs e);
+		/// <summary>
+		/// Delegate to handle data_sm_resp.
+		/// </summary>
+		public delegate void DataSmRespEventHandler(object source, DataSmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle deliver_sm.
+		/// </summary>
+		public delegate void DeliverSmEventHandler(object source, DeliverSmEventArgs e);
+		/// <summary>
+		/// Delegate to handle deliver_sm_resp.
+		/// </summary>
+		public delegate void DeliverSmRespEventHandler(object source, DeliverSmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle replace_sm.
+		/// </summary>
+		public delegate void ReplaceSmEventHandler(object source, ReplaceSmEventArgs e);
+		/// <summary>
+		/// Delegate to handle replace_sm_resp.
+		/// </summary>
+		public delegate void ReplaceSmRespEventHandler(object source, ReplaceSmRespEventArgs e);
+		/// <summary>
+		/// Delegate to handle submit_multi.
+		/// </summary>
+		public delegate void SubmitMultiEventHandler(object source, SubmitMultiEventArgs e);
+		/// <summary>
+		/// Delegate to handle submit_multi_resp.
+		/// </summary>
+		public delegate void SubmitMultiRespEventHandler(object source, SubmitMultiRespEventArgs e);
+	
+		#endregion delegates
+
+		#region constructors
+		
+		/// <summary>
+		/// Creates a default SMPPCommunicator, with port 9999, bindtype set to 
+		/// transceiver, host set to localhost, NPI type set to ISDN, TON type 
+		/// set to International, version set to 3.4, enquire link interval set 
+		/// to 0(disabled), sleep time after socket failure set to 10 seconds, 
+		/// and address range, password, system type and system ID set to null 
+		///(no value).
+		/// </summary>
+		/// <param name="container">The container that will hold this 
+		/// component.</param>
+		public SMPPCommunicator(IContainer container)
+		{
+			// Required for Windows.Forms Class Composition Designer support
+			InitCommunicator();
+			container.Add(this);
+			InitializeComponent();
+		}
+		
+		/// <summary>
+		/// Creates a default SMPPCommunicator, with port 9999, bindtype set to 
+		/// transceiver, host set to localhost, NPI type set to ISDN, TON type 
+		/// set to International, version set to 3.4, enquire link interval set 
+		/// to 0(disabled), sleep time after socket failure set to 10 seconds, 
+		/// and address range, password, system type and system ID set to null 
+		///(no value).
+		/// </summary>
+		public SMPPCommunicator()
+		{
+			InitCommunicator();
+			
+			InitializeComponent();
+		}
+
+		#endregion constructors
+
+		
+		private void delTest() {
+		
+		}
+		/// <summary>
+		/// Sends a user-specified Pdu(see the RoaminSMPP base library for
+		/// Pdu types).  This allows complete flexibility for sending Pdus.
+		/// </summary>
+		/// <param name="packet">The Pdu to send.</param>
+		public void SendPdu(Pdu packet)
+		{
+			bool sendFailed = true;
+			
+			while(sendFailed)
+			{
+				try
+				{
+					packet.ToMsbHexEncoding();
+					asClient.Send(packet.PacketBytes);
+					sendFailed = false;
+				}
+				catch(Exception exc)
+				{
+					if(OnError != null)
+					{
+						OnError(this, new CommonErrorEventArgs(exc));
+					}
+
+					//try to stay alive
+					if((exc.Message.ToLower().IndexOf("socket is closed")>= 0 || 
+						exc.Message.ToLower().IndexOf("unable to write data to the transport connection")>= 0))
+					{
+						System.Threading.Thread.Sleep(SleepTimeAfterSocketFailure * 1000);
+						Bind();
+					}
+					else	
+					{
+						//don't know what happened, but kick out
+						sendFailed = false;
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Connects and binds the SMPPCommunicator to the SMSC, using the
+		/// values that have been set in the constructor and through the
+		/// properties.  This will also start the timer that sends enquire_link packets 
+		/// at regular intervals, if it has been enabled.
+		/// </summary>
+		public void Bind()
+		{
+			try
+			{
+				if(asClient != null)
+					asClient.Disconnect();
+			}
+			catch
+			{
+				//drop it on the floor
+			}
+
+			//connect
+			try 
+			{
+				asClient = new AsyncSocketClient(10240, null,
+					new AsyncSocketClient.MessageHandler(ClientMessageHandler),
+					new AsyncSocketClient.SocketClosingHandler(ClientCloseHandler),
+					new AsyncSocketClient.ErrorHandler(ClientErrorHandler));
+
+				asClient.Connect(Host, Port);
+
+				SmppBind request = new SmppBind();
+				request.SystemId = SystemId;
+				request.Password = Password;
+				request.SystemType = SystemType;
+				request.InterfaceVersion = Version;
+				request.AddressTon = TonType;
+				request.AddressNpi = NpiType;
+				request.AddressRange = AddressRange;
+				request.BindType = BindType;
+
+				SendPdu(request);
+				_SentUnbindPacket = false;
+
+				if(_EnquireLinkInterval > 0)
+				{
+					if(timer == null)
+					{
+						timer = new System.Timers.Timer();
+						timer.Elapsed += new ElapsedEventHandler(TimerElapsed);
+					}
+
+					if(timer != null)		//reset the old timer
+					{
+						timer.Stop();
+
+						timer.Interval = EnquireLinkInterval * 1000;
+						timer.Start();
+					}
+				}
+			} 
+			catch(Exception exc)
+			{
+				if(OnError != null)
+				{
+					OnError(this, new CommonErrorEventArgs(exc));
+				}
+			}
+		}
+
+		/// <summary>
+		/// Unbinds the SMPPCommunicator from the SMSC then disconnects the socket
+		/// when it receives the unbind response from the SMSC.  This will also stop the 
+		/// timer that sends out the enquire_link packets if it has been enabled.  You need to 
+		/// explicitly call this to unbind.; it will not be done for you.
+		/// </summary>
+		public void Unbind()
+		{
+			if(timer != null)
+				timer.Stop();
+			
+			if(!_SentUnbindPacket)
+			{
+				SmppUnbind request = new SmppUnbind();
+				SendPdu(request);
+				_SentUnbindPacket = true;
+			}
+		}
+
+		#region internal methods		
+		/// <summary>
+		/// Callback method to handle received messages.  The AsyncSocketClient
+		/// library calls this; don't call it yourself.
+		/// </summary>
+		/// <param name="client">The client to receive messages from.</param>
+		internal void ClientMessageHandler(AsyncSocketClient client)
+		{
+			try 
+			{
+				Queue responseQueue = new PduFactory().GetPduQueue(client.Buffer);
+				ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessPduQueue), responseQueue);
+			} 
+			catch(Exception exception)
+			{
+				if(OnError != null)
+				{
+					CommonErrorEventArgs e = new CommonErrorEventArgs(exception);
+					OnError(this, e);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Callback method to handle socket closing.
+		/// </summary>
+		/// <param name="client">The client to receive messages from.</param>
+		internal void ClientCloseHandler(AsyncSocketClient client)
+		{
+			//fire off a closing event
+			if(OnClose != null)
+			{
+				System.EventArgs e = new System.EventArgs();
+				OnClose(this, e);
+			}
+		}
+
+		/// <summary>
+		/// Callback method to handle errors.
+		/// </summary>
+		/// <param name="client">The client to receive messages from.</param>
+		/// <param name="exception">The generated exception.</param>
+		internal void ClientErrorHandler(AsyncSocketClient client,
+			Exception exception)
+		{
+			//fire off an error handler
+			if(OnError != null)
+			{
+				CommonErrorEventArgs e = new CommonErrorEventArgs(exception);
+				OnError(this, e);
+			}
+		}
+		#endregion internal methods
+
+		#region private methods
+		
+				/// <summary>
+		/// Goes through the packets in the queue and fires events for them.  Called by the
+		/// threads in the ThreadPool.
+		/// </summary>
+		/// <param name="queueStateObj">The queue of byte packets.</param>
+		private void ProcessPduQueue(object queueStateObj)
+		{
+			Queue responseQueue = queueStateObj as Queue;
+
+			foreach(Pdu response in responseQueue)
+			{
+				//based on each Pdu, fire off an event
+				if(response != null)
+					FireEvents(response);
+			}
+		}
+		
+		/// <summary>
+		/// Sends out an enquire_link packet.
+		/// </summary>
+		/// <param name="sender"></param>
+		/// <param name="ea"></param>
+		private void TimerElapsed(object sender, ElapsedEventArgs ea)
+		{
+			SendPdu(new SmppEnquireLink());
+		}
+
+		/// <summary>
+		/// Fires an event off based on what Pdu is sent in.
+		/// </summary>
+		/// <param name="response">The response to fire an event for.</param>
+		private void FireEvents(Pdu response)
+		{
+			//here we go...
+			if(response is SmppBindResp)
+			{
+				if(OnBindResp != null)
+				{
+					OnBindResp(this, new BindRespEventArgs((SmppBindResp)response));
+				}
+			} 
+			else if(response is SmppUnbindResp)
+			{
+				//disconnect
+				asClient.Disconnect();
+				if(OnUnboundResp != null)
+				{
+					OnUnboundResp(this, new UnbindRespEventArgs((SmppUnbindResp)response));
+				}
+			} 
+			else if(response is SmppAlertNotification)
+			{
+				if(OnAlert != null)
+				{
+					OnAlert(this, new AlertEventArgs((SmppAlertNotification)response));
+				}
+			}	
+			else if(response is SmppSubmitSmResp)
+			{
+				if(OnSubmitSmResp != null)
+				{
+					OnSubmitSmResp(this,
+						new SubmitSmRespEventArgs((SmppSubmitSmResp)response));
+				}
+			}
+			else if(response is SmppEnquireLinkResp)
+			{
+				if(OnEnquireLinkResp != null)
+				{
+					OnEnquireLinkResp(this, new EnquireLinkRespEventArgs((SmppEnquireLinkResp)response));
+				}
+			}
+			else if(response is SmppSubmitSm)
+			{
+				if(OnSubmitSm != null)
+				{
+					OnSubmitSm(this, new SubmitSmEventArgs((SmppSubmitSm)response));
+				}
+				else
+				{
+					//default a response
+					SmppSubmitSmResp pdu = new SmppSubmitSmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.MessageId = System.Guid.NewGuid().ToString().Substring(0, 10);
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppQuerySm)
+			{
+				if(OnQuerySm != null)
+				{
+					OnQuerySm(this, new QuerySmEventArgs((SmppQuerySm)response));
+				}
+				else
+				{
+					//default a response
+					SmppQuerySmResp pdu = new SmppQuerySmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppGenericNack)
+			{
+				if(OnGenericNack != null)
+				{
+					OnGenericNack(this, new GenericNackEventArgs((SmppGenericNack)response));
+				}
+			}
+			else if(response is SmppEnquireLink)
+			{
+				if(OnEnquireLink != null)
+				{
+					OnEnquireLink(this, new EnquireLinkEventArgs((SmppEnquireLink)response));
+				}
+				
+				//send a response back
+				SmppEnquireLinkResp pdu = new SmppEnquireLinkResp();
+				pdu.SequenceNumber = response.SequenceNumber;
+				pdu.CommandStatus = 0;
+
+				SendPdu(pdu);
+			}
+			else if(response is SmppUnbind)
+			{
+				if(OnUnbind != null)
+				{
+					OnUnbind(this, new UnbindEventArgs((SmppUnbind)response));
+				}
+				else
+				{
+					//default a response
+					SmppUnbindResp pdu = new SmppUnbindResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppBind)
+			{
+				if(OnBind != null)
+				{
+					OnBind(this, new BindEventArgs((SmppBind)response));
+				}
+				else
+				{
+					//default a response
+					SmppBindResp pdu = new SmppBindResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+					pdu.SystemId = "Generic";
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppCancelSm)
+			{
+				if(OnCancelSm != null)
+				{
+					OnCancelSm(this, new CancelSmEventArgs((SmppCancelSm)response));
+				}
+				else
+				{
+					//default a response
+					SmppCancelSmResp pdu = new SmppCancelSmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppCancelSmResp)
+			{
+				if(OnCancelSmResp != null)
+				{
+					OnCancelSmResp(this, new CancelSmRespEventArgs((SmppCancelSmResp)response));
+				}
+			}
+			else if(response is SmppCancelSmResp)
+			{
+				if(OnCancelSmResp != null)
+				{
+					OnCancelSmResp(this, new CancelSmRespEventArgs((SmppCancelSmResp)response));
+				}
+			}
+			else if(response is SmppQuerySmResp)
+			{
+				if(OnQuerySmResp != null)
+				{
+					OnQuerySmResp(this, new QuerySmRespEventArgs((SmppQuerySmResp)response));
+				}
+			}
+			else if(response is SmppDataSm)
+			{
+				if(OnDataSm != null)
+				{
+					OnDataSm(this, new DataSmEventArgs((SmppDataSm)response));
+				}
+				else
+				{
+					//default a response
+					SmppDataSmResp pdu = new SmppDataSmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+					pdu.MessageId = "Generic";
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppDataSmResp)
+			{
+				if(OnDataSmResp != null)
+				{
+					OnDataSmResp(this, new DataSmRespEventArgs((SmppDataSmResp)response));
+				}
+			}
+			else if(response is SmppDeliverSm)
+			{
+				if(OnDeliverSm != null)
+				{
+					OnDeliverSm(this, new DeliverSmEventArgs((SmppDeliverSm)response));
+				}
+				else
+				{
+					//default a response
+					SmppDeliverSmResp pdu = new SmppDeliverSmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppDeliverSmResp)
+			{
+				if(OnDeliverSmResp != null)
+				{
+					OnDeliverSmResp(this, new DeliverSmRespEventArgs((SmppDeliverSmResp)response));
+				}
+			}
+			else if(response is SmppReplaceSm)
+			{
+				if(OnReplaceSm != null)
+				{
+					OnReplaceSm(this, new ReplaceSmEventArgs((SmppReplaceSm)response));
+				}
+				else
+				{
+					//default a response
+					SmppReplaceSmResp pdu = new SmppReplaceSmResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppReplaceSmResp)
+			{
+				if(OnReplaceSmResp != null)
+				{
+					OnReplaceSmResp(this, new ReplaceSmRespEventArgs((SmppReplaceSmResp)response));
+				}
+			}
+			else if(response is SmppSubmitMulti)
+			{
+				if(OnSubmitMulti != null)
+				{
+					OnSubmitMulti(this, new SubmitMultiEventArgs((SmppSubmitMulti)response));
+				}
+				else
+				{
+					//default a response
+					SmppSubmitMultiResp pdu = new SmppSubmitMultiResp();
+					pdu.SequenceNumber = response.SequenceNumber;
+					pdu.CommandStatus = 0;
+	
+					SendPdu(pdu);
+				}
+			}
+			else if(response is SmppSubmitMultiResp)
+			{
+				if(OnSubmitMultiResp != null)
+				{
+					OnSubmitMultiResp(this, new SubmitMultiRespEventArgs((SmppSubmitMultiResp)response));
+				}
+			}
+		}
+	
+		/// <summary>
+		/// Initializes the SMPPCommunicator with some default values.
+		/// </summary>
+		private void InitCommunicator()
+		{		
+			Port = 9999;
+			BindType = SmppBind.BindingType.BindAsTransceiver;
+			Host = "localhost";
+			NpiType = Pdu.NpiType.ISDN;
+			TonType = Pdu.TonType.International; 
+			Version = SmppBind.SmppVersionType.Version3_4;
+			AddressRange = null;
+			Password = null;
+			SystemId = null;
+			SystemType = null;
+			EnquireLinkInterval = 0;
+			SleepTimeAfterSocketFailure = 10;
+		}
+		#endregion private methods
+		
+		#region Component Designer generated code
+		
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		protected void InitializeComponent()
+		{
+			components = new System.ComponentModel.Container();
+		}
+		#endregion
+		
+		/// <summary>
+		/// Disposes of this component.  Called by the framework; do not call it 
+		/// directly.
+		/// </summary>
+		/// <param name="disposing">This is set to false during garbage collection but 
+		/// true during a disposal.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if(disposing)
+			{
+				if(components != null)
+				{
+					components.Dispose();
+				}
+			}
+			
+			try
+			{
+				if(!_SentUnbindPacket)
+					Unbind();
+			}
+			catch
+			{
+				//drop it on the floor
+			}
+			base.Dispose(disposing);
+		}
+	}
+}
diff --git a/Utility/DestinationAddress.cs b/Utility/DestinationAddress.cs
new file mode 100644
index 0000000..1956c28
--- /dev/null
+++ b/Utility/DestinationAddress.cs
@@ -0,0 +1,258 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Marker/utility class to define destination addresses for the submit_multi.
+	/// </summary>
+	public sealed class DestinationAddress
+	{
+		private Pdu.TonType _DestinationAddressTon = Pdu.TonType.International;
+		private Pdu.NpiType _DestinationAddressNpi = Pdu.NpiType.ISDN;
+		private string _DestinationAddress = string.Empty;
+		private string _DistributionList = string.Empty;
+		private bool _IsDistributionList = false;
+		
+		#region properties
+		
+		/// <summary>
+		/// Type of number for destination SME.
+		/// </summary>
+		public Pdu.TonType DestinationAddressTon
+		{
+			get
+			{
+				return _DestinationAddressTon;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator for destination SME
+		/// </summary>
+		public Pdu.NpiType DestinationAddressNpi
+		{
+			get
+			{
+				return _DestinationAddressNpi;
+			}
+		}
+		
+		/// <summary>
+		/// Destination Address of destination SME
+		/// </summary>
+		public string DestAddress
+		{
+			get
+			{
+				return _DestinationAddress;
+			}
+		}
+		
+		/// <summary>
+		/// Distribution list of destination address
+		/// </summary>
+		public string DistributionList
+		{
+			get
+			{
+				return _DistributionList;
+			}
+		}
+		
+		/// <summary>
+		/// Set to true if this DestinationAddress is a DistributionList.
+		/// </summary>
+		public bool IsDistributionList
+		{
+			get
+			{
+				return _IsDistributionList;
+			}
+		}
+		
+		#endregion properties
+		
+		/// <summary>
+		/// Creates an DestinationAddress address.  This will trim down the address given to
+		/// it for use in future operations.
+		/// </summary>
+		/// <param name="address">The bytes of the response.</param>
+		public DestinationAddress(ref byte[] address)
+		{
+			if(address[0] == 0x01)
+			{
+				_IsDistributionList = false;
+			}
+			else if(address[0] == 0x02)
+			{
+				_IsDistributionList = true;
+			}
+			else
+			{
+				throw new ApplicationException("Unable to determine type of destination address");
+			}
+			
+			if(!IsDistributionList)
+			{
+				_DestinationAddressTon = (Pdu.TonType)address[1];
+				_DestinationAddressNpi = (Pdu.NpiType)address[2];
+				_DestinationAddress = SmppStringUtil.GetCStringFromBody(ref address, 3);
+//				
+//				long length = address.Length - 4;
+//				byte[] newRemainder = new byte[length];
+//				Array.Copy(address, 4, newRemainder, 0, length);
+//				//and change the reference
+//				address = newRemainder;
+//				newRemainder = null;
+			}
+			else
+			{
+				_DistributionList = SmppStringUtil.GetCStringFromBody(ref address, 1);
+//				
+//				long length = address.Length - 4;
+//				byte[] newRemainder = new byte[length];
+//				Array.Copy(address, 4, newRemainder, 0, length);
+//				//and change the reference
+//				address = newRemainder;
+//				newRemainder = null;
+			}
+		}
+		
+		/// <summary>
+		/// Creates a new DestinationAddress.
+		/// </summary>
+		/// <param name="destinationAddressTon">Type of number for destination SME.</param>
+		/// <param name="destinationAddressNpi">Numbering Plan Indicator for destination SME</param>
+		/// <param name="destinationAdress">Destination Address of destination SME</param>
+		public DestinationAddress(
+			Pdu.TonType destinationAddressTon, 
+			Pdu.NpiType destinationAddressNpi, 
+			string destinationAdress)
+		{
+			if(destinationAdress == null || destinationAdress.Length > 20)
+			{
+				throw new ArgumentException(
+					"Destination Adress must be 20 characters or less.");
+			}
+			
+			_IsDistributionList = false;
+			
+			this._DestinationAddressTon = destinationAddressTon;
+			this._DestinationAddressNpi = destinationAddressNpi;
+			this._DestinationAddress = destinationAdress;
+		}
+		
+		/// <summary>
+		/// Creates a new DestinationAddress.
+		/// </summary>
+		/// <param name="distributionList">Distribution list of destination address</param>
+		public DestinationAddress(string distributionList)
+		{
+			if(distributionList == null || distributionList.Length > 20)
+			{
+				throw new ArgumentException(
+					"distribution list must be 20 characters or less.");
+			}
+			
+			_IsDistributionList = true;
+			
+			this._DistributionList = distributionList;
+		}
+		
+		/// <summary>
+		/// Clones this DestinationAddress.
+		/// </summary>
+		/// <returns>The cloned object.</returns>
+		public object Clone()
+		{
+			DestinationAddress temp = null;
+			
+			if(!this.IsDistributionList)
+			{
+				temp = new DestinationAddress(
+					_DestinationAddressTon, _DestinationAddressNpi, _DestinationAddress);
+			}
+			else
+			{
+				temp = new DestinationAddress(_DistributionList);
+			}
+			
+			temp._IsDistributionList = this.IsDistributionList;
+			
+			return temp;
+		}
+		
+		/// <summary>
+		/// Checks to see if two UnsuccessAddresses are equal.
+		/// </summary>
+		/// <param name="obj">The UnsuccessAddresses to check</param>
+		/// <returns>true if obj and this are equal</returns>
+		public override bool Equals(object obj)
+		{
+	    if (obj == null)
+	    {
+	    	return false;
+	    }
+	
+	    if (this.GetType() != obj.GetType())
+	    {
+	    	return false;
+	    }
+	
+	    DestinationAddress da = (DestinationAddress) obj;
+	
+	    if(!da.IsDistributionList)
+	    {
+	    	// value member check
+		    return 
+		    	_DestinationAddressTon.Equals(da._DestinationAddressTon) &&
+		      _DestinationAddressNpi.Equals(da._DestinationAddressNpi) &&
+		      _DestinationAddress.Equals(da._DestinationAddress);
+	    }
+	    else
+	    {
+	    	return _DistributionList.Equals(da._DistributionList);
+	    }
+		}
+		
+		/// <summary>
+		/// Gets the hash code for this object.
+		/// </summary>
+		/// <returns></returns>
+		public override int GetHashCode()
+    {
+			int hashCode = 0;
+			
+			if(!this.IsDistributionList)
+			{
+				hashCode ^= this.DestAddress.GetHashCode();
+				hashCode ^= this.DestinationAddressNpi.GetHashCode();
+				hashCode ^= this.DestinationAddressTon.GetHashCode();
+			}
+			else
+			{
+				hashCode ^= this.DistributionList.GetHashCode();
+			}
+
+			return hashCode;
+    }
+	}
+}
diff --git a/Utility/PduFactory.cs b/Utility/PduFactory.cs
new file mode 100644
index 0000000..fbd5478
--- /dev/null
+++ b/Utility/PduFactory.cs
@@ -0,0 +1,152 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using RoaminSMPP;
+using RoaminSMPP.Packet;
+using RoaminSMPP.Packet.Request;
+using RoaminSMPP.Packet.Response;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Takes incoming packets from an input stream and generates
+	/// PDUs based on the command field.
+	/// </summary>
+	public class PduFactory
+	{
+		/// <summary>
+		/// Constructor.
+		/// </summary>
+		public PduFactory()
+		{
+		}
+		
+		/// <summary>
+		/// Factory method to generate the PDU.
+		/// </summary>
+		/// <param name="incomingPDUs">The SMSC response.</param>
+		/// <returns>The PDU.</returns>
+		public Queue GetPduQueue(byte[] incomingPDUs)
+		{
+			Queue packetQueue = new Queue();
+			//get the first packet
+			byte[] response = null;
+			Pdu packet = null;
+			int newLength = 0;
+			//this needs to start at zero
+			uint CommandLength = 0;
+			
+			//look for multiple PDUs in the response
+			while(incomingPDUs.Length > 0)
+			{
+				//determine if we have another response PDU after this one
+				newLength =(int)(incomingPDUs.Length - CommandLength);
+				//could be empty data or it could be a PDU
+				if(newLength > 0)
+				{
+					//get the next PDU
+					response = Pdu.TrimResponsePdu(incomingPDUs);
+					//there could be none...
+					if(response.Length > 0)
+					{
+						//get the command length and command ID
+						CommandLength = Pdu.DecodeCommandLength(response);
+						//trim the packet down so we can look for more PDUs
+						long length = incomingPDUs.Length - CommandLength;
+						byte[] newRemainder = new byte[length];
+						Array.Copy(incomingPDUs, CommandLength, newRemainder, 0, length);
+						incomingPDUs = newRemainder;
+						newRemainder = null;
+						if(CommandLength > 0)
+						{
+							//process
+							packet = GetPDU(response);
+							if(packet != null)
+								packetQueue.Enqueue(packet);
+						}
+					}
+					else
+					{
+						//kill it off and return
+						incomingPDUs = new Byte[0];
+					}
+				}
+			}
+			
+			return packetQueue;
+		}
+		
+		/// <summary>
+		/// Gets a single PDU based on the response bytes.
+		/// </summary>
+		/// <param name="response">The SMSC response.</param>
+		/// <returns>The PDU corresponding to the bytes.</returns>
+		private Pdu GetPDU(byte[] response)
+		{
+			Pdu.CommandIdType commandID = Pdu.DecodeCommandId(response);
+			Pdu packet;
+			switch(commandID)
+			{
+				case Pdu.CommandIdType.alert_notification:
+					packet = new SmppAlertNotification(response);
+					break;
+				case Pdu.CommandIdType.bind_receiver_resp:
+				case Pdu.CommandIdType.bind_transceiver_resp:
+				case Pdu.CommandIdType.bind_transmitter_resp:
+					packet = new SmppBindResp(response);
+					break;
+				case Pdu.CommandIdType.cancel_sm_resp:
+					packet = new SmppCancelSmResp(response);
+					break;
+				case Pdu.CommandIdType.data_sm_resp:
+					packet = new SmppDataSmResp(response);
+					break;
+				case Pdu.CommandIdType.deliver_sm:
+					packet = new SmppDeliverSm(response);
+					break;
+				case Pdu.CommandIdType.enquire_link_resp:
+					packet = new SmppEnquireLinkResp(response);
+					break;
+				case Pdu.CommandIdType.outbind:
+					packet = new SmppOutbind(response);
+					break;
+				case Pdu.CommandIdType.query_sm_resp:
+					packet = new SmppQuerySmResp(response);
+					break;
+				case Pdu.CommandIdType.replace_sm_resp:
+					packet = new SmppReplaceSmResp(response);
+					break;
+				case Pdu.CommandIdType.submit_multi_resp:
+					packet = new SmppSubmitMultiResp(response);
+					break;
+				case Pdu.CommandIdType.submit_sm_resp:
+					packet = new SmppSubmitSmResp(response);
+					break;
+				case Pdu.CommandIdType.unbind_resp:
+					packet = new SmppUnbindResp(response);
+					break;
+				default:
+					packet = null;
+					break;
+			}
+
+			return packet;
+		}
+	}
+}
diff --git a/Utility/PduUtil.cs b/Utility/PduUtil.cs
new file mode 100644
index 0000000..398f18e
--- /dev/null
+++ b/Utility/PduUtil.cs
@@ -0,0 +1,255 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Collections;
+using System.Text;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Holds common functionality for requests.
+	/// </summary>
+	public class PduUtil
+	{			
+		#region constants
+		
+		private const int SUBADDRESS_MIN = 2;
+		private const int SUBADDRESS_MAX = 23;
+		
+		#endregion constants
+		/// <summary>
+		/// Do not instantiate
+		/// </summary>
+		private PduUtil()
+		{
+		}
+		
+		/// <summary>
+		/// Inserts the short message into the PDU ArrayList.
+		/// </summary>
+		/// <param name="pdu">The PDU to put the short message into.</param>
+		/// <param name="ShortMessage">The short message to insert.</param>
+		/// <returns>The length of the short message.</returns>
+		public static byte InsertShortMessage(ArrayList pdu, object ShortMessage)
+		{
+			byte[] msg;
+			
+			if(ShortMessage == null)
+			{
+				msg = new Byte[]{0x00};
+			}
+			else if(ShortMessage is string)
+			{
+				msg =  Encoding.ASCII.GetBytes((string)ShortMessage);
+			}
+			else if(ShortMessage is byte[])
+			{
+				msg =(byte[])ShortMessage;
+			}
+			else
+			{
+				throw new ArgumentException("Short Message must be a string or byte array.");
+			}
+			//			if(msg.Length >= MessageLcd2.SHORT_MESSAGE_LIMIT)
+			//				throw new ArgumentException(
+			//					"Short message cannot be longer than " +
+			//					MessageLcd2.SHORT_MESSAGE_LIMIT + " octets.");
+			
+			byte SmLength = (byte)msg.Length;
+			pdu.Add(SmLength);
+			pdu.AddRange(msg);
+			
+			return SmLength;
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a receipted message ID into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetReceiptedMessageId(Pdu pdu, string val)
+		{
+			const int MAX_RECEIPTED_ID_LEN = 65;
+			if(val == null)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.receipted_message_id, string.Empty);
+			}
+			else if(val.Length <= MAX_RECEIPTED_ID_LEN)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.receipted_message_id, val);
+			}
+			else
+			{
+				throw new ArgumentException(
+					"receipted_message_id must have length 1-" + MAX_RECEIPTED_ID_LEN);
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a network error code into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetNetworkErrorCode(Pdu pdu, string val)
+		{
+			const int ERR_CODE_LEN = 3;
+			if(val == null || val.Length != ERR_CODE_LEN)
+			{
+				throw new ArgumentException("network_error_code must have length " + ERR_CODE_LEN);
+			}
+			else
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.network_error_code,val);
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts ITS session info into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetItsSessionInfo(Pdu pdu, string val)
+		{
+			const int MAX_ITS = 16;
+			
+			if(val == null)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.its_session_info, string.Empty);
+			}
+			else if(val.Length == MAX_ITS)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.its_session_info, val);
+			}
+			else
+			{
+				throw new ArgumentException("its_session_info must have length " + MAX_ITS);
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a destination subaddress into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetDestSubaddress(Pdu pdu, string val)
+		{
+			if(val.Length >= SUBADDRESS_MIN && val.Length <= SUBADDRESS_MAX)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.dest_subaddress, val);
+			}
+			else
+			{
+				throw new ArgumentException(
+					"Destination subaddress must be between " + SUBADDRESS_MIN + 
+					" and " + SUBADDRESS_MAX + " characters.");
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a source subaddress into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetSourceSubaddress(Pdu pdu, string val)
+		{
+			if(val.Length >= SUBADDRESS_MIN && val.Length <= SUBADDRESS_MAX)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.source_subaddress, val);
+			}
+			else
+			{
+				throw new ArgumentException(
+					"Source subaddress must be between " + SUBADDRESS_MIN + 
+					" and " + SUBADDRESS_MAX + " characters.");
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a callback number into the TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetCallbackNum(Pdu pdu, string val)
+		{
+			const int CALLBACK_NUM_MIN = 4;
+			const int CALLBACK_NUM_MAX = 19;
+			if(val.Length >= CALLBACK_NUM_MIN && val.Length <= CALLBACK_NUM_MAX)
+			{
+				pdu.SetOptionalParamString(
+					(ushort)Pdu.OptionalParamCodes.callback_num, val);
+			}
+			else
+			{
+				throw new ArgumentException(
+					"callback_num size must be between " + CALLBACK_NUM_MIN + 
+					" and " + CALLBACK_NUM_MAX + " characters.");
+			}
+		}
+		
+		/// <summary>
+		/// Takes the given PDU and inserts a message payload into its TLV table.
+		/// </summary>
+		/// <param name="pdu">The PDU to operate on.</param>
+		/// <param name="val">The value to insert.</param>
+		public static void SetMessagePayload(Pdu pdu, object val)
+		{
+			if(val != null)
+				{
+					byte[] encodedValue;
+					if(val is string)
+					{
+						encodedValue = Encoding.ASCII.GetBytes((string)val);
+					}
+					else if(val is byte[])
+					{
+						encodedValue =(byte[])val;
+					}
+					else
+					{
+						throw new ArgumentException("Message Payload must be a string or byte array.");
+					}
+					
+					const int MAX_PAYLOAD_LENGTH = 64000;
+					if(encodedValue.Length < MAX_PAYLOAD_LENGTH)
+					{
+						pdu.SetOptionalParamBytes(
+							(ushort)Pdu.OptionalParamCodes.message_payload, encodedValue);
+					}
+					else
+					{
+						throw new ArgumentException(
+							"Message Payload must be " + MAX_PAYLOAD_LENGTH + " characters or less in size.");
+					}
+				}
+				else
+				{
+					pdu.SetOptionalParamBytes(
+						(ushort)Pdu.OptionalParamCodes.message_payload, new byte[]{0});
+				}
+		}
+	}
+}
diff --git a/Utility/SmppStringUtil.cs b/Utility/SmppStringUtil.cs
new file mode 100644
index 0000000..322ee48
--- /dev/null
+++ b/Utility/SmppStringUtil.cs
@@ -0,0 +1,178 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Text;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Catchall utility class for dealing with strings in SMPP packets.
+	/// </summary>
+	public class SmppStringUtil
+	{
+		/// <summary>
+		/// Do not instantiate.
+		/// </summary>
+		private SmppStringUtil()
+		{
+		}
+		
+		/// <summary>
+		/// Gets the next string from the given byte array.  Note: this
+		/// method also trims off the string from the byte array, so that it can be easily 
+		/// used in subsequent operations.  You have to know the string length; this will not 
+		/// look for a null character(as it is meant to be used with non-null terminated 
+		/// strings).
+		/// </summary>
+		/// <param name="remainder">The byte array to pull the string from.
+		/// This should not contain extraneous data.</param>
+		/// <param name="startIndex">The index to start getting the string from.
+		/// Usually zero.</param>
+		/// <param name="endIndex">The index to end at.  The character at
+		/// this index will not be included.</param>
+		/// <returns>The string retrieved.</returns>
+		public static string GetStringFromBody(ref byte[] remainder, int startIndex, int endIndex)
+		{
+			string result;
+			
+			//make sure we aren't trying to read non-command
+			//data
+			if(endIndex <= remainder.Length)
+			{
+				result = System.Text.Encoding.ASCII.GetString(remainder, startIndex, endIndex - startIndex);
+			}
+			else
+			{
+				result = string.Empty;
+			}
+			
+			//now trim down the remainder-no null character
+			long length = remainder.Length - endIndex;
+			if(length >= 0)
+			{
+				byte[] newRemainder = new byte[length];
+				Array.Copy(remainder, endIndex, newRemainder, 0, length);
+				remainder = newRemainder;
+				newRemainder = null;
+			}
+			
+			return result;
+		}
+		
+		/// <summary>
+		/// Gets the next null-terminated string from the given byte array.  Note: this
+		/// method also trims off the string(including the null character)from the
+		/// byte array, so that it can be easily used in subsequent operations.
+		/// This is equivalent to GetCStringFromBody(ref remainder, 0).
+		/// </summary>
+		/// <param name="remainder">The byte array to
+		/// pull the string from.  This should not
+		/// contain extraneous data.</param>
+		/// <returns>The string retrieved.</returns>
+		public static string GetCStringFromBody(ref byte[] remainder)
+		{
+			return GetCStringFromBody(ref remainder, 0);
+		}
+		
+		/// <summary>
+		/// Gets the next null-terminated string from the given byte array.  Note: this
+		/// method also trims off the string(including the null character)from the
+		/// byte array, so that it can be easily used in subsequent operations.
+		/// </summary>
+		/// <param name="remainder">The byte array to
+		/// pull the string from.  This should not
+		/// contain extraneous data.</param>
+		/// <param name="startIndex">The index to start getting the string from.
+		/// Usually zero.</param>
+		/// <returns>The string retrieved.</returns>
+		public static string GetCStringFromBody(ref byte[] remainder, int startIndex)
+		{
+			int i;
+			
+			//find where the null character(end of string)is
+			//this stops ON the null character
+			for(i = startIndex; i < remainder.Length && remainder[i] != 0x00; i++)
+			{
+				;
+			}
+			
+			return GetCStringFromBody(ref remainder, startIndex, i);
+		}
+		
+		/// <summary>
+		/// Gets the next null-terminated string from the given byte array.  Note: this
+		/// method also trims off the string from the byte array, so that it can be easily used 
+		/// in subsequent operations.
+		/// </summary>
+		/// <param name="remainder">The byte array to pull the string from.
+		/// This should not contain extraneous data.</param>
+		/// <param name="startIndex">The index to start getting the string from.
+		/// Usually zero.</param>
+		/// <param name="endIndex">The index to end at.  The character at
+		/// this index will not be included.</param>
+		/// <returns>The string retrieved.</returns>
+		public static string GetCStringFromBody(ref byte[] remainder, int startIndex, int endIndex)
+		{
+			string result;
+			
+			//make sure we aren't trying to read non-command
+			//data
+			if(endIndex <= remainder.Length)
+			{
+				result = Encoding.ASCII.GetString(remainder, startIndex, endIndex - startIndex);
+			}
+			else
+			{
+				result = string.Empty;
+			}
+			
+			//now trim down the remainder-chop off the null character as well
+			long length = remainder.Length - endIndex - 1;
+			if(length >= 0)
+			{
+				byte[] newRemainder = new byte[length];
+				Array.Copy(remainder, endIndex + 1, newRemainder, 0, length);
+				remainder = newRemainder;
+				newRemainder = null;
+			}
+			
+			return result;
+		}
+		
+		/// <summary>
+		/// Copies the data from the source array, appending a null character to the end.
+		/// This really only has a use for creating null terminated arrays that represent
+		/// strings.
+		/// </summary>
+		/// <param name="source">The source array to copy from.</param>
+		/// <returns></returns>
+		public static byte[] ArrayCopyWithNull(byte[] source)
+		{
+			byte[] temp = new byte[source.Length + 1];
+			for(int i = 0; i < source.Length; i++)
+			{
+				temp[i] = source[i];
+			}
+			//append the null
+			temp[temp.Length - 1] =(byte)0x00;
+			
+			return temp;
+		}
+	}
+}
diff --git a/Utility/TlvTable.cs b/Utility/TlvTable.cs
new file mode 100644
index 0000000..6a04b08
--- /dev/null
+++ b/Utility/TlvTable.cs
@@ -0,0 +1,288 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Net;
+using System.Text;
+using System.Diagnostics;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Tag, length, value table for SMPP PDUs.  The methods in this class assume 
+	/// that the tag passed in is already in network byte order.
+	/// </summary>
+	public class TlvTable
+	{
+		private Hashtable tlvTable;
+		
+		/// <summary>
+		/// Creates a TLV table.
+		/// </summary>
+		public TlvTable()
+		{
+			tlvTable = new Hashtable();
+			tlvTable = Hashtable.Synchronized(tlvTable);
+		}
+		
+		/// <summary>
+		/// Converts the TLV byte array data into the Hashtable.  This will check if
+		/// the passed in data is null or is an empty array so you don't need to
+		/// check it before calling this method.  This is equivalent to
+		/// TranslateTlvDataIntoTable(tlvData, 0).
+		/// </summary>
+		/// <param name="tlvData">The bytes of TLVs.</param>
+		public void TranslateTlvDataIntoTable(byte[] tlvData)
+		{
+			TranslateTlvDataIntoTable(tlvData, 0);
+		}
+		
+		/// <summary>
+		/// Converts the TLV byte array data into the Hashtable.  This will check if
+		/// the passed in data is null or is an empty array so you don't need to check
+		/// it before calling this method.
+		/// </summary>
+		/// <param name="tlvData">The bytes of TLVs.</param>
+		/// <param name="index">The index of the byte array to start at.  This is here
+		/// because in some instances you may not want to start at the
+		/// beginning.</param>
+		public void TranslateTlvDataIntoTable(byte[] tlvData, Int32 index)
+		{
+			if(tlvData == null || tlvData.Length <= 0)
+			{
+				return;
+			}
+			
+			//go through and decode the TLVs
+			while(index < tlvData.Length)
+			{
+				InjectTlv(tlvData, ref index);
+			}
+		}
+		
+		/// <summary>
+		/// Using the given tlvData byte array and the given starting index, inserts
+		/// the tag and value(as a byte array)into the hashtable.  Note that the
+		/// tlvData needs to be in the SMPP v3.4 format(tag, length, value).  This 
+		/// assumes that the tag and length (from the tlvData array) are in network byte order.
+		///
+		/// Note also that this will advance the index by the TLV data length so that
+		/// it may be used for consecutive reads from the same array.
+		/// </summary>
+		/// <param name="tlvData">The TLV data as a byte array.</param>
+		/// <param name="index">The index of the array to start reading from.</param>
+		private void InjectTlv(byte[] tlvData, ref Int32 index)
+		{
+			byte[] temp = new byte[2];
+			temp[0] = tlvData[index];
+			temp[1] = tlvData[index + 1];
+			
+			#if DEBUG
+			Console.WriteLine("tag bytes " + temp[0].ToString("X").PadLeft(2, '0') + 
+			                  temp[1].ToString("X").PadLeft(2, '0'));
+			#endif
+			
+			UInt16 tag = BitConverter.ToUInt16(temp, 0);
+			index += 2;
+			temp[0] = tlvData[index];
+			temp[1] = tlvData[index + 1];
+			UInt16 length = UnsignedNumConverter.SwapByteOrdering(BitConverter.ToUInt16(temp, 0));
+			index += 2;
+			//decode the value
+			
+			#if DEBUG
+			Console.WriteLine("TLV Length " + length);
+			#endif
+			
+			ArrayList data = new ArrayList(length);
+			
+			int total = index + length;
+			for(int k = index;(k < index + length)&& k < tlvData.Length; k++)
+			{
+				data.Add(tlvData[k]);
+			}
+			
+			data.TrimToSize();
+			//add the values to the hashtable
+			tlvTable.Add(tag, data.ToArray(typeof(byte)));
+			//set it up for the next run
+			index += length;
+		}
+		
+		/// <summary>
+		/// Gets the optional parameter bytes associated with the given tag.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <returns>The optional parameter bytes, null if not found.</returns>
+		/// <exception cref="ApplicationException">Thrown if the tag cannot be found.</exception>
+		public byte[] GetOptionalParamBytes(UInt16 tag)
+		{
+			object val = tlvTable[tag];
+			if(val == null)
+			{
+				throw new ApplicationException("TLV tag " + tag + " not found.");
+			}
+			else
+			{
+				byte[] bVal = (byte[])val;
+				#if DEBUG
+				StringBuilder sb = new StringBuilder();
+				sb.Append("Getting tag " + UnsignedNumConverter.SwapByteOrdering(tag));
+				sb.Append("\nValue: ");
+				
+				for(int i = 0; i < bVal.Length; i++) 
+				{
+					sb.Append(bVal[i]);
+					sb.Append(" ");
+				}
+				
+				Console.WriteLine(sb);
+				
+				#endif
+				return bVal;
+			}
+		}
+		
+		/// <summary>
+		/// Gets the optional parameter string associated with the given tag.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <returns>The optional parameter string, the empty string if not found.
+		/// </returns>
+		/// <exception cref="ApplicationException">Thrown if the tag cannot be found.</exception>
+		public string GetOptionalParamString(UInt16 tag)
+		{
+			byte[] val = GetOptionalParamBytes(tag);
+			
+			return Encoding.ASCII.GetString(val);
+		}
+		
+		/// <summary>
+		/// Sets the given TLV(as a byte array)into the table.  This ignores null values.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void SetOptionalParamBytes(UInt16 tag, byte[] val)
+		{
+			#if DEBUG
+			StringBuilder sb = new StringBuilder();
+			sb.Append("Setting tag " + UnsignedNumConverter.SwapByteOrdering(tag));
+			sb.Append("\nValue: ");
+			
+			for(int i = 0; i < val.Length; i++) 
+			{
+				sb.Append(val[i]);
+				sb.Append(" ");
+			}
+			
+			Console.WriteLine(sb);
+			
+			#endif
+			if(val != null)
+			{
+				if(val.Length > UInt16.MaxValue)
+				{
+					throw new Exception("Optional parameter value for " + tag + " is too large.");
+				}
+				tlvTable.Add(tag, val);
+			}
+		}
+		
+		/// <summary>
+		/// Sets the given TLV(as a string)into the table.  This ignores
+		/// null values.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void SetOptionalParamString(UInt16 tag, string val)
+		{
+			if(val != null)
+			{
+				SetOptionalParamBytes(tag, Encoding.ASCII.GetBytes(val));
+			}
+		}
+		
+		/// <summary>
+		/// Allows the updating of TLV values.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		/// <exception cref="ApplicationException">Thrown if the tag cannot be found.</exception>
+		public void UpdateOptionalParamBytes(UInt16 tag, byte[] val)
+		{
+			object obj = tlvTable[tag];
+			
+			if(obj != null)
+			{
+				tlvTable[tag] = val;
+			}
+			else
+			{
+				throw new ApplicationException("TLV tag " + tag + " not found");
+			}
+		}
+		
+		/// <summary>
+		/// Allows the updating of TLV values.
+		/// </summary>
+		/// <param name="tag">The tag in TLV.</param>
+		/// <param name="val">The value of this TLV.</param>
+		public void UpdateOptionalParamString(UInt16 tag, string val)
+		{
+			UpdateOptionalParamBytes(tag, Encoding.ASCII.GetBytes(val));
+		}
+		
+		/// <summary>
+		/// Iterates through the hashtable, gathering the tag, length, and
+		/// value as it goes.  For each entry, it encodes the TLV into a byte
+		/// array.  It is assumed that the tags and length are already in network 
+		/// byte order.
+		/// </summary>
+		/// <returns>An ArrayList consisting of byte array entries, each of which
+		/// is a TLV.  Returns an empty ArrayList if the TLV table is empty.</returns>
+		public ArrayList GenerateByteEncodedTlv()
+		{
+			if(tlvTable == null || tlvTable.Count <= 0)
+			{
+				return new ArrayList(0);
+			}
+			
+			ArrayList tlvs = new ArrayList();
+			IDictionaryEnumerator iterator = tlvTable.GetEnumerator();
+			ArrayList elem = new ArrayList();
+			while(iterator.MoveNext())
+			{
+				elem.Clear();
+				//tag-2 bytes
+				elem.AddRange(BitConverter.GetBytes(((UInt16)iterator.Key)));
+				//length-2 bytes
+				byte[] nextVal = (byte[])iterator.Value;
+				UInt16 tlvLength = UnsignedNumConverter.SwapByteOrdering(((UInt16)(nextVal).Length));
+				elem.AddRange(BitConverter.GetBytes(tlvLength));
+				//value
+				elem.AddRange(nextVal);
+				elem.TrimToSize();
+				//copy it over to a byte array
+				tlvs.Add(elem.ToArray(typeof(byte)));
+			}
+			tlvs.TrimToSize();
+			
+			return tlvs;
+		}
+	}
+}
diff --git a/Utility/UnsignedNumConverter.cs b/Utility/UnsignedNumConverter.cs
new file mode 100644
index 0000000..31e7f1c
--- /dev/null
+++ b/Utility/UnsignedNumConverter.cs
@@ -0,0 +1,66 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Utility class to do big-endian to little endian conversions and the like.
+	/// This is for unsigned numbers only; use the IPAddress class for signed values.
+	/// </summary>
+	public sealed class UnsignedNumConverter
+	{
+		/// <summary>
+		/// Do not instantiate.
+		/// </summary>
+		private UnsignedNumConverter()
+		{
+		}
+		
+		/// <summary>
+		/// Converts from big-endian to little endian and vice versa.
+		/// </summary>
+		/// <param name="val">The value to swap.</param>
+		/// <returns>The byte-swapped value, 0 if val &lt; 0</returns>
+		public static UInt32 SwapByteOrdering(UInt32 val)
+		{
+			if(val < 0)
+				return 0;
+			return((val << 24)& 0xFF000000)+((val << 8)& 0x00FF0000)+
+					((val >> 8)& 0x0000FF00)+((val >> 24)& 0x000000FF);
+		}
+		
+		/// <summary>
+		/// Converts from big-endian to little endian and vice versa.  Don't use
+		/// for negative integers; it has not been tested for that.
+		/// </summary>
+		/// <param name="val">The value to swap.</param>
+		/// <returns>The byte-swapped value, 0 if val &lt; 0</returns>
+		public static UInt16 SwapByteOrdering(UInt16 val)
+		{
+			if(val < 0)
+			{
+				return 0;
+			}
+			
+			UInt16 newVal = (UInt16)(((val << 8)& 0xFF00)+((val >> 8)& 0x00FF));
+			
+			return newVal;
+		}
+	}
+}
diff --git a/Utility/UnsuccessAddress.cs b/Utility/UnsuccessAddress.cs
new file mode 100644
index 0000000..1fa349d
--- /dev/null
+++ b/Utility/UnsuccessAddress.cs
@@ -0,0 +1,181 @@
+/* RoaminSMPP: SMPP communication library
+ * Copyright (C) 2004, 2005 Christopher M. Bouzek
+ *
+ * This file is part of RoaminSMPP.
+ *
+ * RoaminSMPP is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * RoaminSMPP is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lessert General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with RoaminSMPP.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using RoaminSMPP.Packet;
+
+namespace RoaminSMPP.Utility
+{
+	/// <summary>
+	/// Defines an Unsuccess address, used with the response to submit_multi.
+	/// The spec states that both SME addresses and distribution lists can be
+	/// used here, but it only defines for the SME address, so that is all that
+	/// this will handle.
+	/// </summary>
+	public class UnsuccessAddress
+	{
+		private Pdu.TonType _DestinationAddressTon;
+		private Pdu.NpiType _DestinationAddressNpi;
+		private string _DestinationAddress;
+		private uint _ErrorStatusCode;
+		
+		#region properties
+		
+		/// <summary>
+		/// Type of number for destination SME.
+		/// </summary>
+		public Pdu.TonType DestinationAddressTon
+		{
+			get
+			{
+				return _DestinationAddressTon;
+			}
+		}
+		
+		/// <summary>
+		/// Numbering Plan Indicator for destination SME
+		/// </summary>
+		public Pdu.NpiType DestinationAddressNpi
+		{
+			get
+			{
+				return _DestinationAddressNpi;
+			}
+		}
+		
+		/// <summary>
+		/// Destination Address of destination SME
+		/// </summary>
+		public string DestinationAddress
+		{
+			get
+			{
+				return _DestinationAddress;
+			}
+		}
+		
+		/// <summary>
+		/// Indicates the success or failure of the submit_multi request to this
+		/// SME address.
+		/// </summary>
+		public UInt32 ErrorStatusCode
+		{
+			get
+			{
+				return _ErrorStatusCode;
+			}
+		}
+		
+		#endregion properties
+		
+		/// <summary>
+		/// Creates an Unsuccess address.  This will trim down the address given to
+		/// it for use in future operations.
+		/// </summary>
+		/// <param name="address">The bytes of the response.</param>
+		public UnsuccessAddress(ref byte[] address)
+		{
+			_DestinationAddressTon = (Pdu.TonType)address[0];
+			_DestinationAddressNpi = (Pdu.NpiType)address[1];
+			_DestinationAddress = SmppStringUtil.GetCStringFromBody(ref address, 2);
+			//convert error status to host order
+			_ErrorStatusCode = UnsignedNumConverter.SwapByteOrdering(
+									 BitConverter.ToUInt32(address, 0));
+			//now we have to trim off four octets to account for the status code
+			long length = address.Length - 4;
+			byte[] newRemainder = new byte[length];
+			Array.Copy(address, 4, newRemainder, 0, length);
+			//and change the reference
+			address = newRemainder;
+			newRemainder = null;
+		}
+		
+		/// <summary>
+		/// Creates a new UnsuccessAdress.
+		/// </summary>
+		/// <param name="destinationAddressTon">Type of number for destination SME.</param>
+		/// <param name="destinationAddressNpi">Numbering Plan Indicator for destination SME</param>
+		/// <param name="destinationAdress">Destination Address of destination SME</param>
+		/// <param name="ErrorStatusCode">Indicates the success or failure of the submit_multi request 
+		/// to this SME address.</param>
+		public UnsuccessAddress(
+			Pdu.TonType destinationAddressTon, 
+			Pdu.NpiType destinationAddressNpi, 
+			string destinationAdress, 
+			UInt32 ErrorStatusCode)
+		{
+			this._DestinationAddressTon = destinationAddressTon;
+			this._DestinationAddressNpi = destinationAddressNpi;
+			this._DestinationAddress = destinationAdress;
+			this._ErrorStatusCode = ErrorStatusCode;
+		}
+		
+		/// <summary>
+		/// Clones this UnsuccessAddress.
+		/// </summary>
+		/// <returns>The cloned object.</returns>
+		public object Clone()
+		{
+			UnsuccessAddress temp = new UnsuccessAddress(
+				_DestinationAddressTon, _DestinationAddressNpi, _DestinationAddress, _ErrorStatusCode);
+			return temp;
+		}
+		
+		/// <summary>
+		/// Checks to see if two UnsuccessAddresses are equal.
+		/// </summary>
+		/// <param name="obj">The UnsuccessAddresses to check</param>
+		/// <returns>true if obj and this are equal</returns>
+		public override bool Equals(object obj)
+		{
+	    if (obj == null)
+	    {
+	    	return false;
+	    }
+	
+	    if (this.GetType() != obj.GetType())
+	    {
+	    	return false;
+	    }
+	
+	    // safe because of the GetType check
+	    UnsuccessAddress us = (UnsuccessAddress) obj;
+	
+	    // value member check
+	    return 
+	    	_DestinationAddressTon.Equals(us._DestinationAddressTon) &&
+	      _DestinationAddressNpi.Equals(us._DestinationAddressNpi) &&
+	      _DestinationAddress.Equals(us._DestinationAddress) &&
+	     	_ErrorStatusCode.Equals(us._ErrorStatusCode);
+		}
+		
+		/// <summary>
+		/// Gets the hash code for this object.
+		/// </summary>
+		/// <returns></returns>
+		public override int GetHashCode()
+    {
+			int hashCode = 0;
+			hashCode ^= this.DestinationAddress.GetHashCode();
+			hashCode ^= this.DestinationAddressNpi.GetHashCode();
+			hashCode ^= this.DestinationAddressTon.GetHashCode();
+			hashCode ^= this.ErrorStatusCode.GetHashCode();
+
+			return hashCode;
+    }
+	}
+}
diff --git a/version.txt b/version.txt
new file mode 100644
index 0000000..1d4c65c
--- /dev/null
+++ b/version.txt
@@ -0,0 +1,3 @@
+major=1
+minor=0
+name=flux