Holds the state information for a Tunnels.
Inheritance: System.Edge
Esempio n. 1
0
        protected bool ShouldClose()
        {
#endif
            Dictionary <Edge, bool> have_passed = new Dictionary <Edge, bool>();
            Stack stack = new Stack();
            stack.Push(_tunnels.GetEnumerator());
            while (stack.Count > 0)
            {
                IEnumerator <Connection> cons = stack.Pop() as IEnumerator <Connection>;
                while (cons.MoveNext())
                {
                    TunnelEdge te = cons.Current.Edge as TunnelEdge;
                    if (te == null)
                    {
                        return(false);
                    }

                    if (have_passed.ContainsKey(te))
                    {
                        continue;
                    }
                    have_passed[te] = true;
                    stack.Push(cons);
                    cons = te.Overlap.GetEnumerator();
                }
            }
            return(true);
        }
Esempio n. 2
0
        /// <summary>Common code to Create an outgoing edge.</summary>
        protected void CreateEdge(TunnelEdgeCallbackAction teca, List <Connection> overlap)
        {
            if (_connections.Contains(teca.TunnelTA.Target))
            {
                FailedEdgeCreate(teca);
                return;
            }

            TunnelEdge te = null;

            while (true)
            {
                te = new TunnelEdge(this, (TunnelTransportAddress)_local_tas[0],
                                    teca.TunnelTA, _iasf.GetForwarderSelector(), overlap);
                lock (_sync) {
                    if (!_id_to_tunnel.ContainsKey(te.LocalID))
                    {
                        _id_to_tunnel[te.LocalID] = te;
                        break;
                    }
                }
                // Arriving here, implies another TunnelEdge will be created and this
                // one needs to be closed
                te.Close();
            }

            te.CloseEvent += CloseHandler;

            teca.Success.Value   = true;
            teca.Exception.Value = null;
            teca.Edge.Value      = te;

            _node.EnqueueAction(teca);
        }
Esempio n. 3
0
        public void HandleRpc(ISender caller, string method, IList args, object rs)
        {
            if (method.Equals("Sync"))
            {
                TunnelEdge te = (caller as ReqrepManager.ReplyState).ReturnPath as TunnelEdge;
                if (te == null)
                {
                    throw new Exception(String.Format(
                                            "{0} must be called from a TunnelEdge.", method));
                }

                IDictionary dict = args[0] as IDictionary;
                if (dict == null)
                {
                    throw new Exception(method + "\'s parameter is an IDictionary!");
                }

                UpdateNeighborIntersection(te, dict);
                _node.Rpc.SendResult(rs, true);
            }
            else if (method.Equals("RequestSync"))
            {
                _node.Rpc.SendResult(rs, _ito.GetSyncMessage(null, _node.Address, _connections));
            }
            else
            {
                throw new Exception(String.Format("No such method: {0}.", method));
            }
        }
Esempio n. 4
0
        /// <summary>When a TunnelEdge closes, we must remove it from our
        /// hashtable.</summary>
        protected void CloseHandler(object o, EventArgs ea)
        {
            TunnelEdge te = o as TunnelEdge;

            lock (_sync) {
                _id_to_tunnel.Remove(te.LocalID);
            }
        }
Esempio n. 5
0
        public void Test()
        {
            AHAddress        addr = new AHAddress(new System.Security.Cryptography.RNGCryptoServiceProvider());
            TransportAddress ta   = TransportAddressFactory.CreateInstance("brunet.tcp://169.0.5.1:5000");
            FakeEdge         fe   = new FakeEdge(ta, ta);
            Connection       fcon = new Connection(fe, addr, "structured", null, null);

            List <Connection> overlap = new List <Connection>();

            overlap.Add(fcon);
            TunnelTransportAddress tta   = new TunnelTransportAddress(addr, overlap);
            TunnelEdge             te1   = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
            Connection             t1con = new Connection(te1, addr, "structured", null, null);

            overlap = new List <Connection>();
            overlap.Add(t1con);
            TunnelEdge te2   = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
            Connection t2con = new Connection(te2, addr, "structured", null, null);

            overlap = new List <Connection>();
            overlap.Add(t2con);
            TunnelEdge te3   = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
            Connection t3con = new Connection(te3, addr, "structured", null, null);

            overlap = new List <Connection>();
            overlap.Add(t3con);
            TunnelEdge te4   = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
            Connection t4con = new Connection(te4, addr, "structured", null, null);

            overlap = new List <Connection>();
            overlap.Add(t4con);
            TunnelEdge te5   = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
            Connection t5con = new Connection(te5, addr, "structured", null, null);

            Assert.AreEqual(te5.ShouldClose(), false, "Shouldn't close yet...");
            te1.DisconnectionHandler(fcon);
            Assert.AreEqual(te5.ShouldClose(), true, "Should close...");

            overlap.Add(t5con);
            overlap.Add(t3con);
            overlap.Add(t1con);
            te2.UpdateNeighborIntersection(overlap);
            Assert.AreEqual(te5.ShouldClose(), true, "Should close... 2");
        }
Esempio n. 6
0
        /// <summary>Used to send data over the tunnel via forwarding senders
        /// using a randomly selected peer from our overlap list.</summary>
        public void HandleEdgeSend(Edge from, ICopyable data)
        {
            TunnelEdge te        = from as TunnelEdge;
            Connection forwarder = te.NextForwarder;

            if (te.RemoteID == -1)
            {
                Address target = (te.RemoteTA as TunnelTransportAddress).Target;
                ISender sender = new ForwardingSender(_node, forwarder.Address, target);
                sender.Send(new CopyList(PType.Protocol.Tunneling, te.MId, data));
            }
            else
            {
                try {
                    forwarder.Edge.Send(new CopyList(te.Header, te.MId, data));
                } catch {
                    // We could be sending aon a closed edge... we could deal with this
                    // better, but let's just let the system take its natural course.
                }
            }
        }
Esempio n. 7
0
        /// <summary>Where data packets prepended with a tunnel come.  Here we
        /// receive data as well as create new TunnelEdges.</summary>
        public void HandleData(MemBlock data, ISender return_path, object state)
        {
            AHSender         ah_from = return_path as AHSender;
            ForwardingSender fs_from = return_path as ForwardingSender;
            AHAddress        target  = null;

            if (ah_from == null)
            {
                if (fs_from == null)
                {
                    return;
                }
                target = (AHAddress)fs_from.Destination;
            }
            else
            {
                target = (AHAddress)ah_from.Destination;
            }

            int remote_id = NumberSerializer.ReadInt(data, 0);
            int local_id  = NumberSerializer.ReadInt(data, 4);

            TunnelEdge te = null;

            // No locally assigned ID, so we'll create a new TunnelEdge and assign it one.
            // This could be hit many times by the same RemoteID, but it is safe since
            // we'll attempt Linkers on all of them and he'll only respond to the first
            // one he receives back.
            if (local_id == -1)
            {
                if (fs_from == null)
                {
                    throw new Exception("No LocalID assigned but not from a useful sender!");
                }

                ConnectionList cons  = _connections;
                int            index = cons.IndexOf(fs_from.Forwarder);
                if (index < 0)
                {
                    return;
                }

                List <Connection> overlap_addrs = new List <Connection>();
                overlap_addrs.Add(cons[index]);

                while (true)
                {
                    te = new TunnelEdge(this, (TunnelTransportAddress)_local_tas[0],
                                        new TunnelTransportAddress(target, overlap_addrs),
                                        _iasf.GetForwarderSelector(), overlap_addrs, remote_id);
                    lock (_sync) {
                        if (!_id_to_tunnel.ContainsKey(te.LocalID))
                        {
                            _id_to_tunnel[te.LocalID] = te;
                            break;
                        }
                    }
                    // Arriving here, implies another TunnelEdge will be created and this
                    // one needs to be closed
                    te.Close();
                }

                local_id = te.LocalID;

                te.CloseEvent += CloseHandler;
                SendEdgeEvent(te);
            }

            if (!_id_to_tunnel.TryGetValue(local_id, out te))
            {
                // Maybe we closed this edge
                // throw new Exception("No such edge");
                // Old behavior would ignore these packets...
                return;
            }
            else if (te.RemoteID == -1)
            {
                // We created this, but we haven't received a packet yet
                te.RemoteID = remote_id;
            }
            else if (te.RemoteID != remote_id)
            {
                // Either we closed this edge and it was reallocated or something is up!
                // throw new Exception("Receiving imposter packet...");
                // Old behavior would ignore these packets...
                return;
            }

            if (te.IsClosed)
            {
                throw new Exception("Edge is closed...");
            }

            // Chop off the Ids
            data = data.Slice(8);
            te.ReceivedPacketEvent(data);
        }
Esempio n. 8
0
        /// <summary>Whenever the node receives a new StatusMessage from a tunnel,
        /// we use this to build a consisting of the intersection of our peers
        /// creating a table of potential tunneling options.  We close the edge if
        /// it is empty.</summary>
        protected void UpdateNeighborIntersection(TunnelEdge from, IDictionary msg)
        {
            List <Connection> overlap = _ito.EvaluateOverlap(_connections, msg);

            from.UpdateNeighborIntersection(overlap);
        }
Esempio n. 9
0
    public void Test()
    {
      AHAddress addr = new AHAddress(new System.Security.Cryptography.RNGCryptoServiceProvider());
      TransportAddress ta = TransportAddressFactory.CreateInstance("brunet.tcp://169.0.5.1:5000");
      FakeEdge fe = new FakeEdge(ta, ta);
      Connection fcon = new Connection(fe, addr, "structured", null, null);

      List<Connection> overlap = new List<Connection>();
      overlap.Add(fcon);
      TunnelTransportAddress tta = new TunnelTransportAddress(addr, overlap);
      TunnelEdge te1 = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
      Connection t1con = new Connection(te1, addr, "structured", null, null);

      overlap = new List<Connection>();
      overlap.Add(t1con);
      TunnelEdge te2 = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
      Connection t2con = new Connection(te2, addr, "structured", null, null);

      overlap = new List<Connection>();
      overlap.Add(t2con);
      TunnelEdge te3 = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
      Connection t3con = new Connection(te3, addr, "structured", null, null);

      overlap = new List<Connection>();
      overlap.Add(t3con);
      TunnelEdge te4 = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
      Connection t4con = new Connection(te4, addr, "structured", null, null);

      overlap = new List<Connection>();
      overlap.Add(t4con);
      TunnelEdge te5 = new TunnelEdge(null, tta, tta, new SimpleForwarderSelector(), overlap);
      Connection t5con = new Connection(te5, addr, "structured", null, null);

      Assert.AreEqual(te5.ShouldClose(), false, "Shouldn't close yet...");
      te1.DisconnectionHandler(fcon);
      Assert.AreEqual(te5.ShouldClose(), true, "Should close...");

      overlap.Add(t5con);
      overlap.Add(t3con);
      overlap.Add(t1con);
      te2.UpdateNeighborIntersection(overlap);
      Assert.AreEqual(te5.ShouldClose(), true, "Should close... 2");
    }