Пример #1
0
        private bool HandleReceiveQueue()
        {
            II2NPHeader msg;

            while (true)
            {
                lock ( ReceiveQueue )
                {
                    if (ReceiveQueue.Count == 0)
                    {
                        return(true);
                    }
                    msg = ReceiveQueue.Last.Value;
                    ReceiveQueue.RemoveLast();
                }

                switch (msg.MessageType)
                {
                case I2NPMessage.MessageTypes.VariableTunnelBuildReply:
                    var vtreply = HandleReceivedTunnelBuild((VariableTunnelBuildReplyMessage)msg.Message);
                    if (!vtreply)
                    {
                        return(false);
                    }
                    break;

                default:
                    Logging.Log($"OutboundTunnel {TunnelDebugTrace} HandleReceiveQueue: Dropped {msg.MessageType}");
                    break;
                }
            }
        }
Пример #2
0
        private bool HandleReceiveQueue()
        {
            II2NPHeader msg = null;
            List <TunnelDataMessage> tdmsgs = null;

            lock ( ReceiveQueue )
            {
                if (ReceiveQueue.Count == 0)
                {
                    return(true);
                }

                if (ReceiveQueue.Any(mq => mq.MessageType == I2NPMessage.MessageTypes.TunnelData))
                {
                    var removelist = ReceiveQueue.Where(mq => mq.MessageType == I2NPMessage.MessageTypes.TunnelData);
                    tdmsgs = removelist.Select(mq => (TunnelDataMessage)mq.Message).ToList();
                    foreach (var one in removelist.ToArray())
                    {
                        ReceiveQueue.Remove(one);
                    }
                }
                else
                {
                    msg = ReceiveQueue.Last.Value;
                    ReceiveQueue.RemoveLast();
                }
            }

            if (tdmsgs != null)
            {
                HandleTunnelData(tdmsgs);
                return(true);
            }

            DebugUtils.LogDebug("InboundTunnel " + TunnelDebugTrace + " HandleReceiveQueue: " + msg.MessageType.ToString());

            switch (msg.MessageType)
            {
            case I2NPMessage.MessageTypes.TunnelData:
                throw new NotImplementedException("Should not happen " + TunnelDebugTrace);

            case I2NPMessage.MessageTypes.TunnelBuildReply:
                ThreadPool.QueueUserWorkItem(cb =>
                {
                    TunnelProvider.Inst.HandleTunnelBuildReply((II2NPHeader16)msg, (TunnelBuildReplyMessage)msg.Message);
                });
                return(true);

            case I2NPMessage.MessageTypes.VariableTunnelBuildReply:
                ThreadPool.QueueUserWorkItem(cb =>
                {
                    TunnelProvider.Inst.HandleVariableTunnelBuildReply((II2NPHeader16)msg, (VariableTunnelBuildReplyMessage)msg.Message);
                });
                return(true);

            case I2NPMessage.MessageTypes.DeliveryStatus:
#if LOG_ALL_TUNNEL_TRANSFER
                DebugUtils.LogDebug("InboundTunnel " + TunnelDebugTrace + ": DeliveryStatus: " + msg.Message.ToString());
#endif

                ThreadPool.QueueUserWorkItem(cb => {
                    lock (DeliveryStatusReceivedLock) if (DeliveryStatusReceived != null)
                        {
                            DeliveryStatusReceived((DeliveryStatusMessage)msg.Message);
                        }
                });
                break;

            case I2NPMessage.MessageTypes.DatabaseStore:
                var ds = (DatabaseStoreMessage)msg.Message;
                ThreadPool.QueueUserWorkItem(cb =>
                {
                    TunnelProvider.HandleDatabaseStore(ds);
                });
                break;

            case I2NPMessage.MessageTypes.Garlic:
#if LOG_ALL_TUNNEL_TRANSFER
                DebugUtils.Log("InboundTunnel " + TunnelDebugTrace + ": Garlic: " + msg.Message.ToString());
#endif

                ThreadPool.QueueUserWorkItem(cb =>
                {
                    lock (GarlicMessageReceivedLock) if (GarlicMessageReceived != null)
                        {
                            GarlicMessageReceived((GarlicMessage)msg.Message);
                        }
                });
                break;

            default:
                DebugUtils.LogWarning("InboundTunnel " + TunnelDebugTrace + " HandleReceiveQueue: Dropped " + msg.ToString());
                break;
            }

            return(true);
        }