/// <summary>
        /// expect transport event from transport.<para/>
        /// if event arrived and packet data buffer is empty, return event directly.<para/>
        /// decode packet from packet data buffer, return packet if arrived, otherwise, return event.
        /// </summary>
        /// <param name="timeout">
        /// a TimeSpan struct that specifies the timeout of waiting for a packet or event from the transport.
        /// </param>
        /// <returns>
        /// a TransportEvent object that contains the expected event from transport.
        /// </returns>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for packet coming.
        /// </exception>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for event coming.
        /// </exception>
        /// <exception cref="ObjectDisposedException">
        /// thrown when this object is disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// thrown when stream client is not connected, must invoke Connect() first.
        /// </exception>
        public TransportEvent ExpectTransportEvent(TimeSpan timeout)
        {
            if (disposed)
            {
                throw new ObjectDisposedException("StreamTransport");
            }

            if (this.thread == null)
            {
                throw new InvalidOperationException(
                          "stream client is not connected, must invoke Connect() first.");
            }

            // decode packet
            StackPacket packet = this.ExpectPacket(timeout);

            // if packet is decoded, return it.
            if (packet != null)
            {
                return(new TransportEvent(
                           EventType.ReceivedPacket, this.localEndPoint, null, this.localEndPoint, packet));
            }

            // if no packet, and there is event coming, return event.
            // set timeout to zero, must not wait for event coming.
            return(eventQueue.Dequeue(new TimeSpan()));
        }
        /// <summary>
        /// expect transport event from transport.<para/>
        /// if event arrived and packet data buffer is empty, return event directly.<para/>
        /// decode packet from packet data buffer, return packet if arrived, otherwise, return event.
        /// </summary>
        /// <param name="timeout">
        /// a TimeSpan struct that specifies the timeout of waiting for a packet or event from the transport.
        /// </param>
        /// <returns>
        /// a TransportEvent object that contains the expected event from transport.
        /// </returns>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for packet coming.
        /// </exception>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for event coming.
        /// </exception>
        /// <exception cref="ObjectDisposedException">
        /// thrown when this object is disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// thrown when the udp client is not connected to server, must invoke Start() first.
        /// </exception>
        public TransportEvent ExpectTransportEvent(TimeSpan timeout)
        {
            if (disposed)
            {
                throw new ObjectDisposedException("UdpClientTransport");
            }

            if (this.udpClient == null)
            {
                throw new InvalidOperationException("udp client is not start, must invoke Start() first.");
            }

            try
            {
                object localEP  = this.LspHookedLocalEP;
                object remoteEP = null;

                // decode packet
                StackPacket packet = this.GetPacket(timeout, true, out remoteEP);

                // if packet is decoded, return it.
                return(new TransportEvent(EventType.ReceivedPacket, remoteEP, localEP, packet));
            }
            catch (InvalidOperationException exc)
            {
                if (exc.Data.Count == 0)
                {
                    throw;
                }
            }

            // if no packet, and there is event coming, return event.
            // set timeout to zero, must not wait for event coming.
            return(eventQueue.Dequeue(new TimeSpan()));
        }
        /// <summary>
        /// expect transport event from transport.<para/>
        /// if event arrived and packet data buffer is empty, return event directly.<para/>
        /// decode packet from packet data buffer, return packet if arrived, otherwise, return event.
        /// </summary>
        /// <param name="timeout">
        /// a TimeSpan struct that specifies the timeout of waiting for a packet or event from the transport.
        /// </param>
        /// <returns>
        /// a TransportEvent object that contains the expected event from transport.
        /// </returns>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for packet coming.
        /// </exception>
        /// <exception cref="TimeoutException">
        /// thrown when timeout to wait for event coming.
        /// </exception>
        /// <exception cref="ObjectDisposedException">
        /// thrown when this object is disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// thrown when tcp client is not connected to server, must invoke Connect() first.
        /// </exception>
        public TransportEvent ExpectTransportEvent(TimeSpan timeout)
        {
            if (disposed)
            {
                throw new ObjectDisposedException("TcpClientTransport");
            }

            if (this.stream == null)
            {
                throw new InvalidOperationException(
                          "tcp client is not connected to server, must invoke Connect() first.");
            }

            // decode packet
            StackPacket packet = this.ExpectPacket(timeout);

            // if packet is decoded, return it.
            if (packet != null)
            {
                return(new TransportEvent(
                           EventType.ReceivedPacket, this.localEndPoint, this.remoteEndPoint, this.localEndPoint, packet));
            }

            // eventQueue == null which should only happens in dispose during disconnect
            // Temporally adding wait loop would avoid calling on the null object
            while (eventQueue == null)
            {
                System.Threading.Thread.Sleep(100);
            }

            // if no packet, and there is event coming, return event.
            // set timeout to zero, must not wait for event coming.
            return(eventQueue.Dequeue(new TimeSpan()));
        }
 /// <summary>
 /// Get result of request
 /// </summary>
 public SmbdRequestResult GetRequestResult(
     TimeSpan timeout,
     RequestType type)
 {
     if (type == RequestType.Receive)
     {
         return(receiveRequestResult.Dequeue(timeout));
     }
     return(otherRequestResult.Dequeue(timeout));
 }
Ejemplo n.º 5
0
        /// <summary>
        /// dequeue the received event from queue.
        /// </summary>
        /// <param name="eventQueue">
        /// a SyncFilterQueue&lt;TransportEvent&gt; 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&lt;TransportEvent&gt; 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);
        }
Ejemplo n.º 6
0
        /// <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&lt;TransportEvent&gt; 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.");
                }
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// expect packet from transport.<para/>
        /// the underlayer transport must be TcpClient, Stream or NetbiosClient.
        /// </summary>
        /// <param name="timeout">
        /// a TimeSpan object that indicates the timeout to expect event.
        /// </param>
        /// <returns>
        /// a StackPacket object that specifies the received packet.
        /// </returns>
        /// <exception cref="ObjectDisposedException">
        /// thrown when this object is disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// thrown when stream client is not connected, must invoke Connect() first.
        /// </exception>
        public StackPacket ExpectPacket(TimeSpan timeout)
        {
            if (disposed)
            {
                throw new ObjectDisposedException("StreamTransport");
            }

            if (this.stream == null)
            {
                throw new InvalidOperationException(
                          "stream client is not connected, must invoke Connect() first.");
            }


            StackPacket packet = packetCache.Dequeue(timeout);

            return(packet);
        }
Ejemplo n.º 8
0
        /// <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);
        }