ToString() public method

public ToString ( ) : string
return string
コード例 #1
0
        /* //////////////////////////////
         *
         * Here are all the normal methods of TcpEdgeListener
         *
         * //////////////////////////////
         */


        public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb)
        {
            try {
                if (!IsStarted)
                {
                    throw new EdgeException("TcpEdgeListener is not started");
                }
                else if (ta.TransportAddressType != TransportAddress.TAType.Tcp)
                {
                    throw new EdgeException(ta.TransportAddressType.ToString()
                                            + " is not my type: Tcp");
                }
                else if (_ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny)
                {
                    //Too bad.  Can't make this edge:
                    throw new EdgeException(ta.ToString() + " is not authorized");
                }
                else
                {
                    //Everything looks good:
                    ArrayList tmp_ips = new ArrayList();
                    tmp_ips.Add(((IPTransportAddress)ta).GetIPAddress());
                    CreationState cs = new CreationState(ecb,
                                                         new Queue(tmp_ips),
                                                         ((IPTransportAddress)ta).Port,
                                                         this);
                    ActionQueue.Enqueue(cs);
                }
            } catch (Exception e) {
                ecb(false, null, e);
            }
        }
コード例 #2
0
        //adding some kind of factory methods
        public static TransportAddress CreateInstance(string s)
        {
            var ta_cache            = Interlocked.Exchange <WeakValueTable <string, TransportAddress> >(ref _ta_cache, null);
            TransportAddress result = null;

            if (ta_cache != null)
            {
                try {
                    result = ta_cache.GetValue(s);
                    if (result == null)
                    {
                        result = NoCacheCreateInstance(s);
                        string r_ts = result.ToString();
                        if (r_ts.Equals(s))
                        {
                            //Keep the internal reference which is being saved already
                            s = r_ts;
                        }
                        ta_cache.Replace(s, result);
                    }
                }
                finally {
                    Interlocked.Exchange <WeakValueTable <string, TransportAddress> >(ref _ta_cache, ta_cache);
                }
            }
            else
            {
                result = NoCacheCreateInstance(s);
            }
            return(result);
        }
コード例 #3
0
        /**
         * Implements the EdgeListener function to
         * create edges of this type.
         */
        public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb)
        {
            Edge      e  = null;
            Exception ex = null;

            if (!IsStarted)
            {
                ex = new EdgeException("UdpEdgeListener is not started");
            }
            else if (ta.TransportAddressType != this.TAType)
            {
                ex = new EdgeException(ta.TransportAddressType.ToString()
                                       + " is not my type: " + this.TAType.ToString());
            }
            else if (_ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny)
            {
                ex = new EdgeException(ta.ToString() + " is not authorized");
            }
            else
            {
                IPAddress  first_ip = ((IPTransportAddress)ta).GetIPAddress();
                IPEndPoint end      = new IPEndPoint(first_ip, ((IPTransportAddress)ta).Port);
                /* We have to keep our mapping of end point to edges up to date */
                lock ( _id_ht ) {
                    //Get a random ID for this edge:
                    int id;
                    do
                    {
                        id = _rand.Next();
                        //Make sure we don't have negative ids
                        if (id < 0)
                        {
                            id = ~id;
                        }
                    } while(_id_ht.Contains(id) || id == 0);
                    e          = new UdpEdge(this, false, end, _local_ep, id, 0);
                    _id_ht[id] = e;
                }
                NatDataPoint dp = new NewEdgePoint(DateTime.UtcNow, e);
                Interlocked.Exchange <NatHistory>(ref _nat_hist, _nat_hist + dp);
                Interlocked.Exchange <IEnumerable>(ref _nat_tas, new NatTAs(_tas, _nat_hist));

                try {
                    /* Tell me when you close so I can clean up the table */
                    e.CloseEvent += this.CloseHandler;
                } catch (Exception x) {
                    e  = null;
                    ex = x;
                }
            }

            if (e != null)
            {
                ecb(true, e, null);
            }
            else
            {
                ecb(false, null, ex);
            }
        }
コード例 #4
0
ファイル: TransportAddress.cs プロジェクト: pcbing/brunet
        //adding some kind of factory methods
        public static TransportAddress CreateInstance(string s)
        {
            Cache            ta_cache = Interlocked.Exchange <Cache>(ref _ta_cache, null);
            TransportAddress result   = null;

            if (ta_cache != null)
            {
                try {
                    result = (TransportAddress)ta_cache[s];
                    if (result == null)
                    {
                        result = NoCacheCreateInstance(s);
                        string r_ts = result.ToString();
                        if (r_ts.Equals(s))
                        {
                            //Keep the internal reference which is being saved already
                            s = r_ts;
                        }
                        ta_cache[s] = result;
                    }
                }
                finally {
                    Interlocked.Exchange <Cache>(ref _ta_cache, ta_cache);
                }
            }
            else
            {
                result = NoCacheCreateInstance(s);
            }
            return(result);
        }
コード例 #5
0
        /** return the base TransportAddress and the path associated with it
         */
        public static TransportAddress SplitPath(TransportAddress ta, out string path)
        {
            string tas = ta.ToString();
            // Need to be careful of the case ta:////ta:9/
            int  init_idx = tas.IndexOf("://") + 3;
            int  idx      = init_idx;
            int  pos      = 0;
            bool next     = false;

            for (; idx < tas.Length; idx++)
            {
                if (tas[idx] == '/')
                {
                    if (!next)
                    {
                        pos = idx;
                    }
                }
                else
                {
                    next = false;
                }
            }

            if (pos > 0)
            {
                path = tas.Substring(pos);
                return(TransportAddressFactory.CreateInstance(tas.Substring(0, pos)));
            }
            else
            {
                path = "/";
                return(ta);
            }
        }
コード例 #6
0
        protected static TransportAddress CacheInstance(TransportAddress ta)
        {
            var ta_cache = Interlocked.Exchange <WeakValueTable <string, TransportAddress> >(ref _ta_cache, null);

            if (ta_cache != null)
            {
                try {
                    var ta2 = ta_cache.GetValue(ta.ToString());
                    if (ta.Equals(ta2))
                    {
                        ta = ta2;
                    }
                    else
                    {
                        ta_cache.Replace(ta.ToString(), ta);
                    }
                }
                finally {
                    Interlocked.Exchange <WeakValueTable <string, TransportAddress> >(ref _ta_cache, ta_cache);
                }
            }
            return(ta);
        }
コード例 #7
0
        public void Test()
        {
            TransportAddress tas = TransportAddressFactory.CreateInstance("b.s://234580");

            Assert.AreEqual(tas.ToString(), "b.s://234580", "Simulation string");
            Assert.AreEqual((tas as SimulationTransportAddress).ID, 234580, "Simulation id");
            Assert.AreEqual(TransportAddress.TAType.S, tas.TransportAddressType, "Simulation ta type");
            TransportAddress ta1 = TransportAddressFactory.CreateInstance("brunet.udp://10.5.144.69:5000");

            Assert.AreEqual(ta1.ToString(), "brunet.udp://10.5.144.69:5000", "Testing TA parsing");

            TransportAddress ta2 = TransportAddressFactory.CreateInstance("brunet.udp://10.5.144.69:5000");

            Assert.AreEqual(ta1, ta2, "Testing TA Equals");



            string           StrLocalHost = Dns.GetHostName();
            IPHostEntry      IPEntry      = Dns.GetHostEntry(StrLocalHost);
            TransportAddress local_ta     = TransportAddressFactory.CreateInstance("brunet.udp://" + IPEntry.AddressList[0].ToString() +
                                                                                   ":" + 5000);
            IEnumerable locals = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Udp, 5000);

            bool match = false;

            foreach (TransportAddress test_ta1 in locals)
            {
                //Console.WriteLine("test_ta: {0}", test_ta1);
                if (test_ta1.Equals(local_ta))
                {
                    match = true;
                }
            }
            Assert.AreEqual(match, true, "testing local TA matches");
            //testing function TA
            TransportAddress func_ta  = TransportAddressFactory.CreateInstance("brunet.function://localhost:3000");
            TransportAddress func_ta2 = TransportAddressFactory.CreateInstance("brunet.function://localhost:3000");

            Assert.AreEqual(func_ta, func_ta2, "equality of instances");
            Assert.IsTrue(func_ta == func_ta2, "reference equality, test of caching");
            Assert.AreEqual(func_ta.ToString(), "brunet.function://localhost:3000", "Testing function TA parsing");
        }
コード例 #8
0
ファイル: PathEdgeListener.cs プロジェクト: hseom/brunet
    /** return the base TransportAddress and the path associated with it
     */
    public static TransportAddress SplitPath(TransportAddress ta, out string path) {
      string tas = ta.ToString();
      // Need to be careful of the case ta:////ta:9/
      int init_idx = tas.IndexOf("://") + 3;
      int idx = init_idx;
      int pos = 0;
      bool next = false;
      for(; idx < tas.Length; idx++) {
        if(tas[idx] == '/') {
          if(!next) {
            pos = idx;
          }
        } else {
          next = false;
        }
      }

      if(pos > 0) {
        path = tas.Substring(pos);
        return TransportAddressFactory.CreateInstance(tas.Substring(0, pos));
      } else {
        path = "/";
        return ta;
      }
    }
コード例 #9
0
ファイル: UdpEdgeListener.cs プロジェクト: bakriy/brunet
    /**
     * Implements the EdgeListener function to 
     * create edges of this type.
     */
    public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb)
    {
      Edge e = null;
      Exception ex = null;
      if( !IsStarted ) {
        ex = new EdgeException("UdpEdgeListener is not started");
      } else if( ta.TransportAddressType != this.TAType ) {
        ex = new EdgeException(ta.TransportAddressType.ToString()
            + " is not my type: " + this.TAType.ToString() );
      } else if( _ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny ) {
        ex = new EdgeException( ta.ToString() + " is not authorized");
      } else {
        IPAddress first_ip = ((IPTransportAddress) ta).GetIPAddress();
        IPEndPoint end = new IPEndPoint(first_ip, ((IPTransportAddress) ta).Port);
        /* We have to keep our mapping of end point to edges up to date */
        lock( _id_ht ) {
          //Get a random ID for this edge:
          int id;
          do {
            id = _rand.Next();
	    //Make sure we don't have negative ids
            if( id < 0 ) { id = ~id; }
          } while( _id_ht.Contains(id) || id == 0 );
          e = new UdpEdge(this, false, end, _local_ep, id, 0);
          _id_ht[id] = e;
        }
        NatDataPoint dp = new NewEdgePoint(DateTime.UtcNow, e);
        Interlocked.Exchange<NatHistory>(ref _nat_hist, _nat_hist + dp);
        Interlocked.Exchange<IEnumerable>(ref _nat_tas, new NatTAs( _tas, _nat_hist ));

        try {
          /* Tell me when you close so I can clean up the table */
          e.CloseEvent += this.CloseHandler;
        } catch (Exception x) {
          e = null;
          ex = x;
        }
      }

      if(e != null) {
        ecb(true, e, null);
      } else {
        ecb(false, null, ex);
      }
    }
コード例 #10
0
    /*
     * Implements the EdgeListener function to 
     * create edges of this type.
     */
    public override void CreateEdgeTo(TransportAddress ta,
                                      EdgeCreationCallback ecb)
    {
      if( !IsStarted )
      {
        // it should return null and not throw an exception
        // for graceful disconnect and preventing others to
        // connect to us after we've disconnected.
        ecb(false, null, new EdgeException("Not started"));
        return;
      }

      if( ta.TransportAddressType != this.TAType ) {
        //Can't make an edge of this type
        ecb(false, null, new EdgeException("Can't make edge of this type"));
        return;
      }
      
      if( _ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny ) {
        //Not authorized.  Can't make this edge:
        ecb(false, null, new EdgeException( ta.ToString() + " is not authorized") );
        return;
      }
      
      int remote_id = ((SimulationTransportAddress) ta).ID;
      //Get the edgelistener: 

      //Outbound edge:
      int delay = 0;
      if(_use_delay) {
        if(LatencyMap != null) {
          // id != 0, so we reduce all by 1
          delay = LatencyMap[_listener_id][remote_id] / 1000;
        } else {
          delay = 100;
        }
      }

      SimulationEdge se_l = new SimulationEdge(this, _listener_id, remote_id, false, delay);
      AddEdge(se_l);

      SimulationEdgeListener remote = (SimulationEdgeListener) _listener_map[remote_id];
      if( remote != null ) {
        //
        // Make sure that the remote listener does not deny 
        // our TAs.
        //

        foreach (TransportAddress ta_local in LocalTAs) {
          if (remote.TAAuth.Authorize(ta_local) == TAAuthorizer.Decision.Deny ) {
          //Not authorized.  Can't make this edge:
            ecb(false, null, new EdgeException( ta_local.ToString() + " is not authorized by remote node.") );
            return;
          }
        }

        SimulationEdge se_r = new SimulationEdge(remote, remote_id, _listener_id, true, delay);
        remote.AddEdge(se_r);

        se_l.Partner = se_r;
        se_r.Partner = se_l;
        remote.SendEdgeEvent(se_r);
      } else {
          //There is no other edge, for now, we use "udp-like"
          //behavior of just making an edge that goes nowhere.
      }
      ecb(true, se_l, null);
    }
コード例 #11
0
    /*
     * Implements the EdgeListener function to 
     * create edges of this type.
     */
    public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb)
    {
      if( !IsStarted ) {
        // it should return null and not throw an exception
        // for graceful disconnect and preventing others to
        // connect to us after we've disconnected.
        ecb(false, null, new EdgeException("Not started"));
        return;
      } else if( ta.TransportAddressType != this.TAType ) {
        //Can't make an edge of this type
        ecb(false, null, new EdgeException("Can't make edge of this type"));
        return;
      } else if( _ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny ) {
        //Not authorized.  Can't make this edge:
        ecb(false, null, new EdgeException( ta.ToString() + " is not authorized") );
        return;
      }
      
      int remote_id = ((SimulationTransportAddress) ta).ID;
      int real_remote_id = (remote_id >= 0) ? remote_id : ~remote_id;

      //Outbound edge:
      int delay = 0;
      if(_use_delay) {
        if(LatencyMap != null) {
          int local = LocalID % LatencyMap.Count;
          int remote = real_remote_id % LatencyMap.Count;
          delay = LatencyMap[local][remote] / 1000;
        } else {
          delay = 100;
        }
      }

      SimulationEdge se_l = new SimulationEdge(this, LocalID, remote_id, false, delay, _ta_type);
      if(real_remote_id == remote_id) {
        CreateRemoteEdge(se_l);
      }
      ecb(true, se_l, null);
    }
コード例 #12
0
        /*
         * Implements the EdgeListener function to
         * create edges of this type.
         */
        public override void CreateEdgeTo(TransportAddress ta,
                                          EdgeCreationCallback ecb)
        {
            if (!IsStarted)
            {
                // it should return null and not throw an exception
                // for graceful disconnect and preventing others to
                // connect to us after we've disconnected.
                ecb(false, null, new EdgeException("Not started"));
                return;
            }

#if FUNCTION_DEBUG
            foreach (TransportAddress local_ta in LocalTAs)
            {
                Console.Error.WriteLine("Create edge local: {0} <-> remote {1}.", local_ta, ta);
            }
#endif

            if (ta.TransportAddressType != this.TAType)
            {
                //Can't make an edge of this type
#if FUNCTION_DEBUG
                Console.Error.WriteLine("Can't make edge of this type.");
#endif
                ecb(false, null, new EdgeException("Can't make edge of this type"));
                return;
            }

            if (_ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny)
            {
                //Not authorized.  Can't make this edge:
#if FUNCTION_DEBUG
                Console.Error.WriteLine("Can't make edge. Remote TA {0} is not authorized locally.", ta);
#endif
                ecb(false, null,
                    new EdgeException(ta.ToString() + " is not authorized"));
                return;
            }

            int remote_id = ((IPTransportAddress)ta).Port;
            //Get the edgelistener:

            //Outbound edge:
            FunctionEdge fe_l = new FunctionEdge(this, _listener_id,
                                                 remote_id, false);
            lock ( _listener_map ) {
                FunctionEdgeListener remote
                    = (FunctionEdgeListener)_listener_map[remote_id];
                if (remote != null)
                {
                    //
                    // Make sure that the remote listener does not deny
                    // our TAs.
                    //

                    foreach (TransportAddress ta_local in LocalTAs)
                    {
                        if (remote.TAAuth.Authorize(ta_local) == TAAuthorizer.Decision.Deny)
                        {
                            //Not authorized.  Can't make this edge:
#if FUNCTION_DEBUG
                            Console.Error.WriteLine("Can't make edge. local TA {0} is not authorized remotely by {1}.", ta_local, ta);
#endif
                            ecb(false, null,
                                new EdgeException(ta_local.ToString() + " is not authorized by remote node."));
                            return;
                        }
                    }

                    FunctionEdge fe_r = new FunctionEdge(remote, remote_id,
                                                         _listener_id, true);
                    fe_l.Partner = fe_r;
                    fe_r.Partner = fe_l;
                    remote.SendEdgeEvent(fe_r);
                }
                else
                {
                    //There is no other edge, for now, we use "udp-like"
                    //behavior of just making an edge that goes nowhere.
                }
                ecb(true, fe_l, null);
            }
        }
コード例 #13
0
ファイル: TransportAddress.cs プロジェクト: hseom/brunet
 protected static TransportAddress CacheInstance(TransportAddress ta) {
   var ta_cache = Interlocked.Exchange<WeakValueTable<string, TransportAddress>>(ref _ta_cache, null);
   if( ta_cache != null ) {
     try {
       var ta2 = ta_cache.GetValue(ta.ToString());
       if(ta.Equals(ta2)) {
         ta = ta2;
       } else {
         ta_cache.Replace(ta.ToString(), ta);
       }
     }
     finally {
       Interlocked.Exchange<WeakValueTable<string, TransportAddress>>(ref _ta_cache, ta_cache);
     }
   }
   return ta;
 }
コード例 #14
0
ファイル: TransportAddress.cs プロジェクト: pcbing/brunet
        public void Test()
        {
            TransportAddress tas = TransportAddressFactory.CreateInstance("b.s://234580");

            Assert.AreEqual(tas.ToString(), "b.s://234580", "Simulation string");
            Assert.AreEqual((tas as SimulationTransportAddress).ID, 234580, "Simulation id");
            Assert.AreEqual(TransportAddress.TAType.S, tas.TransportAddressType, "Simulation ta type");
            TransportAddress ta1 = TransportAddressFactory.CreateInstance("brunet.udp://10.5.144.69:5000");

            Assert.AreEqual(ta1.ToString(), "brunet.udp://10.5.144.69:5000", "Testing TA parsing");

            TransportAddress ta2 = TransportAddressFactory.CreateInstance("brunet.udp://10.5.144.69:5000");

            Assert.AreEqual(ta1, ta2, "Testing TA Equals");

            string           ta_string = "brunet.tunnel://UBU72YLHU5C3SY7JMYMJRTKK4D5BGW22/FE4QWASN+FE4QWASM";
            TransportAddress ta        = TransportAddressFactory.CreateInstance("brunet.tunnel://UBU72YLHU5C3SY7JMYMJRTKK4D5BGW22/FE4QWASN+FE4QWASM");

            Assert.AreEqual(ta.ToString(), ta_string, "testing tunnel TA parsing");
            //Console.WriteLine(ta);

            TunnelTransportAddress tun_ta = (TunnelTransportAddress)TransportAddressFactory.CreateInstance("brunet.tunnel://OIHZCNNUAXTLLARQIOBNCUWXYNAS62LO/CADSL6GV+CADSL6GU");

            ArrayList fwd = new ArrayList();

            fwd.Add(new AHAddress(Base32.Decode("CADSL6GVVBM6V442CETP4JTEAWACLC5A")));
            fwd.Add(new AHAddress(Base32.Decode("CADSL6GUVBM6V442CETP4JTEAWACLC5A")));

            TunnelTransportAddress test_ta = new TunnelTransportAddress(tun_ta.Target, fwd);

            Assert.AreEqual(tun_ta, test_ta, "testing tunnel TA compression enhancements");
            //Console.WriteLine(tun_ta.ToString());
            //Console.WriteLine(test_ta.ToString());
            Assert.AreEqual(tun_ta.ToString(), test_ta.ToString(), "testing tunnel TA compression enhancements (toString)");

            Assert.AreEqual(tun_ta.ContainsForwarder(new AHAddress(Base32.Decode("CADSL6GVVBM6V442CETP4JTEAWACLC5A"))), true,
                            "testing tunnel TA contains forwarder (1)");

            Assert.AreEqual(tun_ta.ContainsForwarder(new AHAddress(Base32.Decode("CADSL6GUVBM6V442CETP4JTEAWACLC5A"))), true,
                            "testing tunnel TA contains forwarder (2)");



            string           StrLocalHost = Dns.GetHostName();
            IPHostEntry      IPEntry      = Dns.GetHostEntry(StrLocalHost);
            TransportAddress local_ta     = TransportAddressFactory.CreateInstance("brunet.udp://" + IPEntry.AddressList[0].ToString() +
                                                                                   ":" + 5000);
            IEnumerable locals = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Udp, 5000);

            bool match = false;

            foreach (TransportAddress test_ta1 in locals)
            {
                //Console.WriteLine("test_ta: {0}", test_ta1);
                if (test_ta1.Equals(local_ta))
                {
                    match = true;
                }
            }
            Assert.AreEqual(match, true, "testing local TA matches");
            //testing function TA
            TransportAddress func_ta  = TransportAddressFactory.CreateInstance("brunet.function://localhost:3000");
            TransportAddress func_ta2 = TransportAddressFactory.CreateInstance("brunet.function://localhost:3000");

            Assert.AreEqual(func_ta, func_ta2, "equality of instances");
            Assert.IsTrue(func_ta == func_ta2, "reference equality, test of caching");
            Assert.AreEqual(func_ta.ToString(), "brunet.function://localhost:3000", "Testing function TA parsing");
        }
コード例 #15
0
ファイル: TcpEdgeListener.cs プロジェクト: pstjuste/brunet
    /* //////////////////////////////
     *
     * Here are all the normal methods of TcpEdgeListener
     *
     * //////////////////////////////
     */


    public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb)
    {
      try {
        if( !IsStarted ) {
          throw new EdgeException("TcpEdgeListener is not started");
        }
        else if( ta.TransportAddressType != TransportAddress.TAType.Tcp ) {
	        throw new EdgeException(ta.TransportAddressType.ToString()
				    + " is not my type: Tcp");
        }
        else if( _ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny ) {
            //Too bad.  Can't make this edge:
	        throw new EdgeException( ta.ToString() + " is not authorized");
        }
        else {
          //Everything looks good:
	        ArrayList tmp_ips = new ArrayList();
	        tmp_ips.Add(((IPTransportAddress)ta).GetIPAddress());
          CreationState cs = new CreationState(ecb,
                                           new Queue( tmp_ips ),
                                           ((IPTransportAddress) ta).Port,
                                           this);
          ActionQueue.Enqueue(cs);
        }
      } catch(Exception e) {
	      ecb(false, null, e);
      }
    }
コード例 #16
0
        /*
         * Implements the EdgeListener function to
         * create edges of this type.
         */
        public override void CreateEdgeTo(TransportAddress ta,
                                          EdgeCreationCallback ecb)
        {
            if (!IsStarted)
            {
                // it should return null and not throw an exception
                // for graceful disconnect and preventing others to
                // connect to us after we've disconnected.
                ecb(false, null, new EdgeException("Not started"));
                return;
            }

            if (ta.TransportAddressType != this.TAType)
            {
                //Can't make an edge of this type
                ecb(false, null, new EdgeException("Can't make edge of this type"));
                return;
            }

            if (_ta_auth.Authorize(ta) == TAAuthorizer.Decision.Deny)
            {
                //Not authorized.  Can't make this edge:
                ecb(false, null, new EdgeException(ta.ToString() + " is not authorized"));
                return;
            }

            int remote_id = ((SimulationTransportAddress)ta).ID;
            //Get the edgelistener:

            //Outbound edge:
            int delay = 0;

            if (_use_delay)
            {
                if (LatencyMap != null)
                {
                    // id != 0, so we reduce all by 1
                    delay = LatencyMap[_listener_id][remote_id] / 1000;
                }
                else
                {
                    lock (_sync) {
                        delay = _rand.Next(10, 250);
                    }
                }
            }

            SimulationEdge se_l = new SimulationEdge(this, _listener_id, remote_id, false, delay);

            AddEdge(se_l);

            SimulationEdgeListener remote = (SimulationEdgeListener)_listener_map[remote_id];

            if (remote != null)
            {
                //
                // Make sure that the remote listener does not deny
                // our TAs.
                //

                foreach (TransportAddress ta_local in LocalTAs)
                {
                    if (remote.TAAuth.Authorize(ta_local) == TAAuthorizer.Decision.Deny)
                    {
                        //Not authorized.  Can't make this edge:
                        ecb(false, null, new EdgeException(ta_local.ToString() + " is not authorized by remote node."));
                        return;
                    }
                }

                SimulationEdge se_r = new SimulationEdge(remote, remote_id, _listener_id, true, delay);
                remote.AddEdge(se_r);

                se_l.Partner = se_r;
                se_r.Partner = se_l;
                remote.SendEdgeEvent(se_r);
            }
            else
            {
                //There is no other edge, for now, we use "udp-like"
                //behavior of just making an edge that goes nowhere.
            }
            ecb(true, se_l, null);
        }