/// <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)
{
// Disconnect with SUT.
Disconnect();
// Free managed resources & other reference types:
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// expect packet from transport.
/// </summary>
/// <param name="buffer">
/// a BytesBuffer object that contains the received data from endpoint.
/// </param>
/// <param name="decoder">
/// a DecodePacketCallback delegate that is used to decode packet from buffer.
/// </param>
/// <param name="endpoint">
/// an object that specifies the endpoint for decoder.<para/>
/// remember: this endpoint must be the endpoint that is returned to the user,
/// that is the endpoint return by Connect().
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="packetCache">
/// a list that contains the stackpackets.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.
/// </returns>
public static StackPacket Visit(
BytesBuffer buffer, DecodePacketCallback decoder, object endpoint,
TimeSpan timeout, SyncFilterQueue <StackPacket> packetCache)
{
// get the packet in packet list.
if (packetCache.Count > 0)
{
return(Utility.GetOne <StackPacket>(packetCache, null));
}
// the consumed length of decoder.
int consumedLength = 0;
// decode packet, return null or at least one packet.
StackPacket[] packets = ExpectMultiPacketsVisitor.Visit(
buffer, decoder, endpoint, timeout, out consumedLength);
// packet is null, buffer is closed, no packet will come.
if (packets == null)
{
return(null);
}
// if packet arrived, add to packet list, and return the first.
foreach (StackPacket packet in packets)
{
packetCache.Enqueue(packet);
}
return(Utility.GetOne <StackPacket>(packetCache, null));
}
/// <summary>
/// enqueue the receivied transport event.<para/>
/// add the transport event to the event queue, for user to expect specified event directly.<para/>
/// add the transport event to data sequence, for user to expect any event(include received packet).<para/>
/// it's thread-safe.
/// </summary>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that stores the received data or event sequence.
/// </param>
/// <param name="transportEvent">
/// a TransportEvent object that specifies the received event.
/// </param>
public static void Enqueue(SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence, TransportEvent transportEvent)
{
lock (eventQueue)
{
sequence.Add(transportEvent, new byte[0], null);
eventQueue.Enqueue(transportEvent);
}
}
/// <summary>
/// dequeue the received event from queue.
/// </summary>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that stores the received data or event sequence.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that specifies the timeout to wait for event.
/// </param>
/// <param name="filter">
/// a Filter<TransportEvent> that specifies the filter to get event.
/// </param>
/// <returns>
/// return a TransportEvent object that stores the event.
/// </returns>
public static TransportEvent Dequeue(
SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence,
TimeSpan timeout, Filter <TransportEvent> filter)
{
TransportEvent transportEvent = eventQueue.Dequeue(timeout, filter);
// remove the event from sequence.
sequence.Remove(transportEvent);
return(transportEvent);
}
/// <summary>
/// remove the specifies transport event from queue and data sequence.<para/>
/// invoke this method when get event from the data sequence.
/// </summary>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="transportEvent">
/// a TransportEvent object that specifies the event to remove.
/// </param>
public static void Remove(
SyncFilterQueue <TransportEvent> eventQueue, TransportEvent transportEvent)
{
lock (eventQueue)
{
TransportEvent removedTransportEvent = eventQueue.Dequeue(new TimeSpan());
if (removedTransportEvent != transportEvent)
{
throw new InvalidOperationException(
"the transport event stores in the event queue and data sequence are not consistence.");
}
}
}
/// <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.thread != null)
{
this.thread.Dispose();
this.thread = null;
}
if (this.transport != null)
{
// the netbios transport may throw exception, donot arise exception.
Utility.SafelyDisconnectNetbiosConnection(this.transport, this.remoteEndPoint);
this.transport.Dispose();
this.transport = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.buffer != null)
{
this.buffer.Dispose();
this.buffer = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <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>
/// get one packet from packet cache.<para/>
/// if no packet, return null.
/// </summary>
/// <param name="packetCache">
/// a SyncFilterQueue queue that stores the packet.
/// </param>
/// <param name="filter">
/// the filter to get packet. if null, do not filter packet.
/// </param>
/// <returns>
/// a packet specified by filter.
/// </returns>
public static PacketType GetOne <PacketType>(SyncFilterQueue <PacketType> packetCache, Filter <PacketType> filter)
{
PacketType packet = default(PacketType);
if (packetCache.Count == 0)
{
return(packet);
}
try
{
packet = packetCache.Dequeue(new TimeSpan(), filter);
}
catch (TimeoutException)
{
}
return(packet);
}
/// <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.listeners != null)
{
// stop listener if exists.
if (this.listeners.Count > 0)
{
this.Stop();
}
this.listeners = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.buffer != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.buffer.Dispose();
this.buffer = 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 UdpClientTransport(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
this.eventQueue = new SyncFilterQueue <TransportEvent>();
this.buffer = new SyncFilterQueue <UdpReceivedBytes>();
this.packetCache = new SyncFilterQueue <IPEndPointStackPacket>();
this.decoder = decodePacketCallback;
}
/// <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;
}
/// <summary>
/// SmbdEndpoint constructor will load RDMA providers and initialize default connection values.
/// </summary>
/// <param name="inboundEntries">maximum number of outstanding Receive requests.</param>
/// <param name="outboundEntries">maximum number of outstanding Send, SendAndInvalidate
/// , Bind, Invalidate, Read, and Write requests.
/// </param>
/// <param name="inboundSegment">inbound segments limit</param>
/// <param name="outboundSegment">outbound segments limit</param>
/// <param name="inboundReadLimit">maximum inbound read limit for the local Network
/// Direct adapter. This value can be zero if you do not support
/// </param>
/// <param name="outboundReadLimit"></param>
/// <param name="inboundDataSize">Max Size of RDMA inbound data</param>
/// <param name="logEvent">Delegate to log SMBD event</param>
public SmbdConnectionEndpoint(
uint inboundEntries,
uint outboundEntries,
uint inboundSegment,
uint outboundSegment,
uint inboundReadLimit,
uint outboundReadLimit,
uint inboundDataSize,
SmbdLogEvent logEvent = null
)
{
this.logEndpointEvent = logEvent;
LogEvent("Loading the providers of registered network drivers.");
initializeStatus = (NtStatus)RdmaProvider.LoadRdmaProviders(out rdmaProvidersList);
this.inboundEntries = inboundEntries;
this.outboundEntries = outboundEntries;
this.inboundSegment = inboundSegment;
this.outboundSegment = outboundSegment;
this.inboundReadLimit = inboundReadLimit;
this.outboundReadLimit = outboundReadLimit;
this.completionQueueDepth = (inboundEntries + outboundEntries);
this.inboundDataSize = inboundDataSize;
isConnected = false;
memoryWindowList = new List<SmbdMemoryWindow>();
receiveRequestList = new List<SmbdRequest>();
locker = new Object();
otherRequestResult = new SyncFilterQueue<SmbdRequestResult>();
receiveRequestResult = new SyncFilterQueue<SmbdRequestResult>();
disconnectSemaphore = new Semaphore(0, 1);
//threadStopSemaphore = new Semaphore(0, THREAD_COUNT);
// one more for Semaphore Release when disconnection
rdmaNotificationSemaphore = new Semaphore(0, (int)completionQueueDepth + 1);
requestCount = 0;
ReceivePostedCount = 0;
#region output provider information
if (initializeStatus != NtStatus.STATUS_SUCCESS)
{
LogEvent(string.Format("Load provider with error code: {0}", (NtStatus)initializeStatus));
return;
}
if (rdmaProvidersList == null)
{
LogEvent("The returned providers list is NULL");
return;
}
LogEvent(string.Format("{0} providers of registered network drivers have been load,", rdmaProvidersList.Length));
int providerIndex = 0;
foreach (RdmaProviderInfo info in rdmaProvidersList)
{
if (info != null)
{
LogEvent(string.Format("Load provider {1}: {0}", info.Path, ++providerIndex));
}
}
LogEvent("Loading providers is completed");
#endregion
}
/// <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>
/// 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.listeners != null)
{
// stop listener if exists.
if (this.listeners.Count > 0)
{
this.Stop();
}
this.listeners = null;
}
if (this.connections != null)
{
// disconnect clients if exists.
if (this.connections.Count > 0)
{
this.Disconnect();
}
this.connections = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.sequence != null)
{
this.sequence.Dispose();
this.sequence = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IVisitorGetAnyPacket interface that specifies the host of visitor.
/// </param>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="skipEvent">
/// a bool value that specifies whether skip the event.<para/>
/// if true, just wait for packet coming; otherwise, both data and event will return.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static TransportEvent Visit(
IVisitorGetAnyData host,
SyncFilterQueue<TransportEvent> eventQueue, DataSequence sequence, TimeSpan timeout, bool skipEvent)
{
// the end time for operation.
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
sequence.Reset();
// try to decode packet from all clients in sequence.
while (true)
{
SequenceItem item = sequence.Next(TimeSpan.MinValue);
// all item in the sequences returned
if (item == null)
{
break;
}
TransportEvent transportEvent = item.Source as TransportEvent;
// if event arrived and donot skip the event, return the event directly.
if (transportEvent != null)
{
if (skipEvent)
{
continue;
}
sequence.Remove(transportEvent);
Utility.Remove(eventQueue, transportEvent);
return transportEvent;
}
object remoteEndPoint;
object localEndPoint;
host.VisitorGetEndPoint(item.Source, out remoteEndPoint, out localEndPoint);
int consumedLength = 0;
StackPacket packet = null;
try
{
// set timeout to zero, must not wait for more data.
// if timeout, process next.
packet = host.VisitorDecodePackets(
item.Source, remoteEndPoint, localEndPoint, out consumedLength);
// remove the sequence information in data sequence.
sequence.Consume(item.Source, consumedLength);
if (packet != null)
{
TcpServerConnection connection = item.Source as TcpServerConnection;
if (connection != null)
{
return connection.VisitorCreateTransportEvent(EventType.ReceivedPacket, packet);
}
else
{
return new TransportEvent(EventType.ReceivedPacket, remoteEndPoint, localEndPoint, packet);
}
}
}
// skip timeout of any host.
catch (TimeoutException)
{
}
}
// waiting for next data coming.
sequence.Next(currentTimeout);
currentTimeout = endTime - DateTime.Now;
}
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IVisitorGetAnyPacket interface that specifies the host of visitor.
/// </param>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="skipEvent">
/// a bool value that specifies whether skip the event.<para/>
/// if true, just wait for packet coming; otherwise, both data and event will return.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static TransportEvent Visit(
IVisitorGetAnyData host,
SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence, TimeSpan timeout, bool skipEvent)
{
// the end time for operation.
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
sequence.Reset();
// try to decode packet from all clients in sequence.
while (true)
{
SequenceItem item = sequence.Next(TimeSpan.MinValue);
// all item in the sequences returned
if (item == null)
{
break;
}
TransportEvent transportEvent = item.Source as TransportEvent;
// if event arrived and donot skip the event, return the event directly.
if (transportEvent != null)
{
if (skipEvent)
{
continue;
}
sequence.Remove(transportEvent);
Utility.Remove(eventQueue, transportEvent);
return(transportEvent);
}
object remoteEndPoint;
object localEndPoint;
host.VisitorGetEndPoint(item.Source, out remoteEndPoint, out localEndPoint);
int consumedLength = 0;
StackPacket packet = null;
try
{
// set timeout to zero, must not wait for more data.
// if timeout, process next.
packet = host.VisitorDecodePackets(
item.Source, remoteEndPoint, localEndPoint, out consumedLength);
// remove the sequence information in data sequence.
sequence.Consume(item.Source, consumedLength);
if (packet != null)
{
TcpServerConnection connection = item.Source as TcpServerConnection;
if (connection != null)
{
return(connection.VisitorCreateTransportEvent(EventType.ReceivedPacket, packet));
}
else
{
return(new TransportEvent(EventType.ReceivedPacket, remoteEndPoint, localEndPoint, packet));
}
}
}
// skip timeout of any host.
catch (TimeoutException)
{
}
}
// waiting for next data coming.
sequence.Next(currentTimeout);
currentTimeout = endTime - DateTime.Now;
}
}
/// <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;
}
/// <summary>
/// SmbdEndpoint constructor will load RDMA providers and initialize default connection values.
/// </summary>
/// <param name="inboundEntries">maximum number of outstanding Receive requests.</param>
/// <param name="outboundEntries">maximum number of outstanding Send, SendAndInvalidate
/// , Bind, Invalidate, Read, and Write requests.
/// </param>
/// <param name="inboundSegment">inbound segments limit</param>
/// <param name="outboundSegment">outbound segments limit</param>
/// <param name="inboundReadLimit">maximum inbound read limit for the local Network
/// Direct adapter. This value can be zero if you do not support
/// </param>
/// <param name="outboundReadLimit"></param>
/// <param name="inboundDataSize">Max Size of RDMA inbound data</param>
/// <param name="logEvent">Delegate to log SMBD event</param>
public SmbdConnectionEndpoint(
uint inboundEntries,
uint outboundEntries,
uint inboundSegment,
uint outboundSegment,
uint inboundReadLimit,
uint outboundReadLimit,
uint inboundDataSize,
SmbdLogEvent logEvent = null
)
{
this.logEndpointEvent = logEvent;
LogEvent("Loading the providers of registered network drivers.");
initializeStatus = (NtStatus)RdmaProvider.LoadRdmaProviders(out rdmaProvidersList);
this.inboundEntries = inboundEntries;
this.outboundEntries = outboundEntries;
this.inboundSegment = inboundSegment;
this.outboundSegment = outboundSegment;
this.inboundReadLimit = inboundReadLimit;
this.outboundReadLimit = outboundReadLimit;
this.completionQueueDepth = (inboundEntries + outboundEntries);
this.inboundDataSize = inboundDataSize;
isConnected = false;
memoryWindowList = new List <SmbdMemoryWindow>();
receiveRequestList = new List <SmbdRequest>();
locker = new Object();
otherRequestResult = new SyncFilterQueue <SmbdRequestResult>();
receiveRequestResult = new SyncFilterQueue <SmbdRequestResult>();
disconnectSemaphore = new Semaphore(0, 1);
//threadStopSemaphore = new Semaphore(0, THREAD_COUNT);
// one more for Semaphore Release when disconnection
rdmaNotificationSemaphore = new Semaphore(0, (int)completionQueueDepth + 1);
requestCount = 0;
ReceivePostedCount = 0;
#region output provider information
if (initializeStatus != NtStatus.STATUS_SUCCESS)
{
LogEvent(string.Format("Load provider with error code: {0}", (NtStatus)initializeStatus));
return;
}
if (rdmaProvidersList == null)
{
LogEvent("The returned providers list is NULL");
return;
}
LogEvent(string.Format("{0} providers of registered network drivers have been load,", rdmaProvidersList.Length));
int providerIndex = 0;
foreach (RdmaProviderInfo info in rdmaProvidersList)
{
if (info != null)
{
LogEvent(string.Format("Load provider {1}: {0}", info.Path, ++providerIndex));
}
}
LogEvent("Loading providers is completed");
#endregion
}
/// <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>
/// 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.thread != null)
{
if(this.thread.IsAlive)
{
this.thread.Abort();
this.thread.Join();
}
this.thread = null;
}
if (this.stream != null)
{
this.stream.Dispose();
this.stream = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// expect packet from transport.
/// </summary>
/// <param name="buffer">
/// a BytesBuffer object that contains the received data from endpoint.
/// </param>
/// <param name="decoder">
/// a DecodePacketCallback delegate that is used to decode packet from buffer.
/// </param>
/// <param name="endpoint">
/// an object that specifies the endpoint for decoder.<para/>
/// remember: this endpoint must be the endpoint that is returned to the user,
/// that is the endpoint return by Connect().
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="packetCache">
/// a list that contains the stackpackets.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.
/// </returns>
public static StackPacket Visit(
BytesBuffer buffer, DecodePacketCallback decoder, object endpoint,
TimeSpan timeout, SyncFilterQueue<StackPacket> packetCache)
{
// get the packet in packet list.
if (packetCache.Count > 0)
{
return Utility.GetOne<StackPacket>(packetCache, null);
}
// the consumed length of decoder.
int consumedLength = 0;
// decode packet, return null or at least one packet.
StackPacket[] packets = ExpectMultiPacketsVisitor.Visit(
buffer, decoder, endpoint, timeout, out consumedLength);
// packet is null, buffer is closed, no packet will come.
if (packets == null)
{
return null;
}
// if packet arrived, add to packet list, and return the first.
foreach (StackPacket packet in packets)
{
packetCache.Enqueue(packet);
}
return Utility.GetOne<StackPacket>(packetCache, null);
}
/// <summary>
/// Initialize Rpce server.
/// </summary>
public RpceServer()
{
this.serverContextManager = new RpceContextManager();
this.receivedTransportEvents = new SyncFilterQueue<RpceTransportEvent>();
}
/// <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.thread != null)
{
this.thread.Dispose();
this.thread = null;
}
if (this.transport != null)
{
// the netbios transport may throw exception, donot arise exception.
Utility.SafelyDisconnectNetbiosConnection(this.transport, this.remoteEndPoint);
this.transport.Dispose();
this.transport = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.buffer != null)
{
this.buffer.Dispose();
this.buffer = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <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:
// because the client uses listener as transport,
// so must stop listener, then dispose client, at last dispose listener.
if (this.connections != null)
{
// stop to accept clients, if exists listener.
if (this.listeners.Count > 0)
{
this.Stop();
}
// disconnect and dispose all clients, if exists.
if (this.connections.Count > 0)
{
this.Disconnect();
}
this.connections = null;
}
// dispose listeners after diposed all clients.
if (this.listeners != null)
{
// dispose all listener if exists.
foreach (NetbiosServerListener listener in this.listeners.Values)
{
listener.Dispose();
}
this.listeners = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.sequence != null)
{
this.sequence.Dispose();
this.sequence = 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;
}
