/// <summary>
/// consturctor.
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that contains the config.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not SocketTransportConfig
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when transportConfig is null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when decodePacketCallback is null.
/// </exception>
public TcpServerTransport(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
this.decoder = decodePacketCallback;
this.listeners = new Dictionary<IPEndPoint, TcpServerListener>();
this.connections = new Dictionary<IPEndPoint, TcpServerConnection>();
this.eventQueue = new SyncFilterQueue<TransportEvent>();
this.sequence = new DataSequence();
this.packetCache = new SyncFilterQueue<IPEndPointStackPacket>();
}
/// <summary>
/// to update the config of transport at runtime.
/// </summary>
/// <param name="config">
/// a TransportConfig object that contains the config to update
/// </param>
/// <exception cref="ObjectDisposedException">
/// thrown when this object is disposed.
/// </exception>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not SocketTransportConfig.
/// </exception>
public void UpdateConfig(TransportConfig config)
{
if (disposed)
{
throw new ObjectDisposedException("TcpServerTransport");
}
SocketTransportConfig socketTransportConfig = config as SocketTransportConfig;
if (socketTransportConfig == null)
{
throw new ArgumentException("transportConfig must be SocketTransportConfig", "config");
}
this.socketConfig = socketTransportConfig;
}
/// <summary>
/// to update the config of transport at runtime.
/// </summary>
/// <param name="config">
/// a TransportConfig object that contains the config to update
/// </param>
/// <exception cref="ObjectDisposedException">
/// thrown when this object is disposed.
/// </exception>
/// <exception cref="InvalidOperationException">
/// thrown when the underlayer transport is null! the config for TransportStack is invalid.
/// </exception>
public virtual void UpdateConfig(TransportConfig config)
{
if (disposed)
{
throw new ObjectDisposedException("TransportStack");
}
if (this.transport == null)
{
throw new InvalidOperationException(
"the underlayer transport is null! the config for TransportStack is invalid.");
}
this.transport.UpdateConfig(config);
}
/// <summary>
/// Constructor. To create the instance of transport specified in the transportConfig.
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that specifies the transport type and parameters.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="InvalidOperationException">
/// thrown when StackTransportType is invalid.
/// </exception>
/// <exception cref="InvalidOperationException">
/// thrown when Role is invalid, for transport type is Tcp, it must be Server or Client.
/// </exception>
/// <exception cref="InvalidOperationException">
/// thrown when Role is invalid, for transport type is Netbios, it must be Server or Client.
/// </exception>
public TransportStack(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
switch (transportConfig.Type)
{
case StackTransportType.Tcp:
if (transportConfig.Role == Role.Client)
{
this.transport = new TcpClientTransport(transportConfig, decodePacketCallback);
}
else if (transportConfig.Role == Role.Server)
{
this.transport = new TcpServerTransport(transportConfig, decodePacketCallback);
}
else
{
throw new InvalidOperationException(
"Role is invalid, for transport type is Tcp, it must be Server or Client.");
}
break;
case StackTransportType.Netbios:
if (transportConfig.Role == Role.Client)
{
this.transport = new NetbiosClientTransport(transportConfig, decodePacketCallback);
}
else if (transportConfig.Role == Role.Server)
{
this.transport = new NetbiosServerTransport(transportConfig, decodePacketCallback);
}
else
{
throw new InvalidOperationException(
"Role is invalid, for transport type is Netbios, it must be Server or Client.");
}
break;
case StackTransportType.Stream:
this.transport = new StreamTransport(transportConfig, decodePacketCallback);
break;
case StackTransportType.Udp:
if (transportConfig.Role == Role.Server)
{
this.transport = new UdpServerTransport(transportConfig, decodePacketCallback);
}
// all other role are equals to Client.
else
{
this.transport = new UdpClientTransport(transportConfig, decodePacketCallback);
}
break;
default:
throw new InvalidOperationException("StackTransportType is invalid.");
}
}
/// <summary>
/// consturctor.
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that contains the config.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not StreamConfig
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when transportConfig is null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when decodePacketCallback is null.
/// </exception>
public RdpbcgrClientTransportStack(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
buffer = new List<byte>();
this.eventQueue = new SyncFilterQueue<TransportEvent>();
this.packetCache = new SyncFilterQueue<StackPacket>();
this.decoder = decodePacketCallback;
}
/// <summary>
/// to update the config of transport at runtime.
/// </summary>
/// <param name="config">
/// a TransportConfig object that contains the config to update
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not StreamTransport
/// </exception>
/// <exception cref="ObjectDisposedException">
/// thrown when this object is disposed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when config is null.
/// </exception>
public void UpdateConfig(TransportConfig config)
{
if (disposed)
{
throw new ObjectDisposedException("StreamTransport");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
buffer = new List<byte>();
StreamConfig theStreamConfig = config as StreamConfig;
if (theStreamConfig == null)
{
throw new ArgumentException("transportConfig must be StreamConfig", "config");
}
this.streamConfig = theStreamConfig;
// if the decoder is null, the instance has not initialized
// do not terminate the thread and return directly.
if (this.decoder == null || this.packetCache == null)
{
return;
}
#region update the underlayer stream.
// abort the blocked receive thread.
if (this.thread != null)
{
this.stopThread = true;
this.thread = null;
}
// reconnect to received data from new stream.
// if the stream is null, just stop the receiver of stream.
if (this.streamConfig.Stream != null)
{
this.Connect();
}
#endregion
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="ldapVersion">The LDAP version that client uses.</param>
/// <param name="config">
/// The transport stack configuration. Note that for ADTS-LDAP, only socket transport is supported.
/// </param>
/// <exception cref="StackException">Thrown when the TransportConfig is not SocketTransportConfig</exception>
/// <exception cref="ArgumentException">
/// Thrown when the stack transport type is neither TCP nor UDP.
/// </exception>
public AdtsLdapClient(AdtsLdapVersion ldapVersion, TransportConfig config)
{
this.ldapVersion = ldapVersion;
this.config = config;
if (ldapVersion == AdtsLdapVersion.V2)
{
this.encoder = new AdtsLdapV2Encoder();
}
else
{
this.encoder = new AdtsLdapV3Encoder();
}
}
/// <summary>
/// Release resources.
/// </summary>
/// <param name = "disposing">
/// If disposing equals true, Managed and unmanaged resources are disposed. if false, Only unmanaged resources
/// can be disposed.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
// If disposing equals true, dispose all managed and unmanaged resources.
if (disposing)
{
// Free managed resources & other reference types:
if (this.transportStack != null)
{
this.transportStack.Dispose();
this.transportStack = null;
}
if (this.security != null)
{
this.security.Dispose();
this.security = null;
}
this.config = null;
this.encoder = null;
this.decoder = null;
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// constructor
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that contains the config.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not SocketTransportConfig
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when transportConfig is null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when decodePacketCallback is null.
/// </exception>
public UdpServerTransport(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
this.listeners = new Dictionary<IPEndPoint, UdpServerListener>();
this.eventQueue = new SyncFilterQueue<TransportEvent>();
this.packetCache = new SyncFilterQueue<IPEndPointStackPacket>();
this.buffer = new SyncFilterQueue<UdpReceivedBytes>();
this.decoder = decodePacketCallback;
}
/// <summary>
/// to update the config of transport at runtime.
/// </summary>
/// <param name="config">
/// a TransportConfig object that contains the config to update
/// </param>
/// <exception cref="ObjectDisposedException">
/// thrown when this object is disposed.
/// </exception>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not NetbiosTransportConfig.
/// </exception>
public void UpdateConfig(TransportConfig config)
{
if (disposed)
{
throw new ObjectDisposedException("NetbiosServerTransport");
}
NetbiosTransportConfig netbiosTransportConfig = config as NetbiosTransportConfig;
if (netbiosTransportConfig == null)
{
throw new ArgumentException("transportConfig must be NetbiosTransportConfig", "config");
}
this.netbiosConfig = netbiosTransportConfig;
}
/// <summary>
/// consturctor.
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that contains the config.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not StreamConfig
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when transportConfig is null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when decodePacketCallback is null.
/// </exception>
public StreamTransport(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
this.buffer = new BytesBuffer();
this.eventQueue = new SyncFilterQueue<TransportEvent>();
this.packetCache = new SyncFilterQueue<StackPacket>();
this.decoder = decodePacketCallback;
}
