public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { SubringTransportAddress sta = ta as SubringTransportAddress; if (sta == null) { ecb(false, null, new Exception("TA Type is not Subring!")); } else if (!sta.Namespace.Equals(_shared_node.Realm)) { ecb(false, null, new Exception("Namespace mismatch")); } else if (sta.Target.Equals(_private_node.Address)) { ecb(false, null, new Exception("You are me!")); } else { SubringEdge se = new SubringEdge(_local_ta, sta, false, new AHExactSender(_shared_node, sta.Target), _ptype); se.CloseEvent += CloseHandler; _it.Add(se); ecb(true, se, null); } }
/* ////////////////////////////// * * 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); } }
/// <summary>Creates an XmppEdge.</summary> public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { if (_ready == 0) { ecb(false, null, new Exception("Xmpp is not authenticated")); } XmppTransportAddress xta = ta as XmppTransportAddress; if (xta == null) { ecb(false, null, new Exception("TA Type is not Xmpp!")); return; } else if (!_xmpp.IsUserOnline(xta.JID)) { ecb(false, null, new Exception("Xmpp user, " + xta.JID + ", is not online.")); return; } XmppEdge xe = new XmppEdge(this, _local_ta, xta, false); _it.Add(xe); xe.CloseEvent += CloseHandler; ecb(true, xe, null); }
/** * 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); } }
public TunnelEdgeCallbackAction(TunnelTransportAddress tta, EdgeCreationCallback ecb) { TunnelTA = tta; Ecb = ecb; Exception = new WriteOnce <Exception>(); Success = new WriteOnce <bool>(); Edge = new WriteOnce <Edge>(); }
public RelayEdgeCallbackAction(RelayTransportAddress tta, EdgeCreationCallback ecb) { RelayTA = tta; Ecb = ecb; Exception = new WriteOnce <Exception>(); Success = new WriteOnce <bool>(); Edge = new WriteOnce <Edge>(); }
public CreationState(EdgeCreationCallback ecb, Queue ipq, int port, TcpEdgeListener tel) { ECB = ecb; IPAddressQueue = ipq; Port = port; TEL = tel; Result = new WriteOnce <object>(); }
/* * 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); }
/// <summary>Does not immediately create an edge to a remote node, instead, /// it tells a timer to wait 5 seconds prior to attempting an edge.</summary> public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { RelayTransportAddress tta = ta as RelayTransportAddress; if (tta == null) { ecb(false, null, new Exception("TA Type is not Relay!")); } else { RelayEdgeCallbackAction teca = new RelayEdgeCallbackAction(tta, ecb); System.Action <DateTime> callback = delegate(DateTime now) { CreateEdgeTo(teca); }; Brunet.Util.FuzzyTimer.Instance.DoAfter(callback, 10000, 0); } }
public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { SubringTransportAddress sta = ta as SubringTransportAddress; if(sta == null) { ecb(false, null, new Exception("TA Type is not Subring!")); } else if(!sta.Namespace.Equals(_shared_node.Realm)) { ecb(false, null, new Exception("Namespace mismatch")); } else if(sta.Target.Equals(_private_node.Address)) { ecb(false, null, new Exception("You are me!")); } else { SubringEdge se = new SubringEdge(_local_ta, sta, false, new AHExactSender(_shared_node, sta.Target), _ptype); se.CloseEvent += CloseHandler; _it.Add(se); ecb(true, se, null); } }
/* * 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); }
/* * 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); } }
/** * This method creates an instance of a tunnel edge to a remote node, given its * tunnel transport URI. * @param ta TransportAddress to create an edge to * @param ecb the EdgeCreationCallback to call when done * @throw EdgeException if we try to call this before calling * Start. */ public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { try { if (!IsStarted) { throw new EdgeException("TunnelEdgeListener not started"); } else if (0 == _running) { throw new EdgeException("TunnelEdgeListener not running"); } else if (ta.TransportAddressType != this.TAType) { throw new EdgeException(ta.TransportAddressType.ToString() + " is not my type: " + this.TAType.ToString()); } else { #if TUNNEL_DEBUG Console.Error.WriteLine("CreateEdgeTo TunnelEdge to: {0}", ta); #endif TunnelTransportAddress tun_ta = ta as TunnelTransportAddress; ArrayList forwarders = new ArrayList(); ArrayList forwarding_edges = new ArrayList(); #if TUNNEL_DEBUG Console.Error.WriteLine("TunnelEdgeListener: Finding structured connections to tunnel over"); #endif IEnumerable struc_cons = _node.ConnectionTable.GetConnections(ConnectionType.Structured); if (struc_cons == null) { #if TUNNEL_DEBUG Console.Error.WriteLine("List of structured connections is null"); #endif } #if TUNNEL_DEBUG Console.Error.WriteLine("TunnelEdgeListener: Browsing list of structured connections"); #endif foreach (Connection con in struc_cons) { #if TUNNEL_DEBUG Console.Error.WriteLine("TunnelEdgeListener: Testing : {0}", con.Address); #endif if (con.Edge.TAType == TransportAddress.TAType.Tunnel) { #if TUNNEL_DEBUG Console.Error.WriteLine("Cannot tunnel over tunnel: " + con.Address.ToString()); #endif continue; } if (!tun_ta.ContainsForwarder(con.Address)) { #if TUNNEL_DEBUG Console.Error.WriteLine("Cannot tunnel over connection: " + con.Address.ToString()); #endif continue; } #if TUNNEL_DEBUG Console.Error.WriteLine("Can tunnel over connection: " + con.Address.ToString()); #endif forwarders.Add(con.Address); forwarding_edges.Add(con.Edge); } if (forwarders.Count < MIN_FORWARDERS) { ecb(false, null, new EdgeException("Cannot create edge over TA: " + tun_ta + ", not many forwarders")); return; } tun_ta = new TunnelTransportAddress(tun_ta.Target, forwarders); //choose a locally unique id lock( _sync ) { //Get a random ID for this edge: int localid; int remoteid = 0; do { localid = _rand.Next(); //Make sure we don't have negative ids if( localid < 0 ) { localid = ~localid; } } while( _id_ht.Contains(localid) || localid == 0 ); //looks like the new edge is ready TunnelEdge e = new TunnelEdge(this, false, _node, tun_ta.Target, forwarders, localid, remoteid); #if TUNNEL_DEBUG Console.Error.WriteLine("Creating an instance of TunnelEdge: {0}", e); Console.Error.WriteLine("remoteid: {0}, localid: {1}", remoteid, localid); #endif _id_ht[localid] = e; //we will defer the new edge event for later //when we actually get a response //now build the packet payload Packet p = null; using(MemoryStream ms = new MemoryStream()) { ms.WriteByte((byte) MessageType.EdgeRequest); NumberSerializer.WriteInt(localid, ms); NumberSerializer.WriteInt(remoteid, ms); #if TUNNEL_DEBUG Console.Error.WriteLine("Written off type, localid, remoteid"); #endif ArrayList args = new ArrayList(); //add the target address byte[] addr_bytes = new byte[Address.MemSize]; _node.Address.CopyTo(addr_bytes); args.Add(addr_bytes.Clone()); #if TUNNEL_DEBUG Console.Error.WriteLine("Added target address"); #endif foreach (Address fwd in forwarders) { //add forwarding addresses fwd.CopyTo(addr_bytes); args.Add(addr_bytes.Clone()); #if TUNNEL_DEBUG Console.Error.WriteLine("Added a forwarding address"); #endif } #if TUNNEL_DEBUG Console.Error.WriteLine("Creating a memory stream holding the payload"); #endif AdrConverter.Serialize(args, ms); p = new AHPacket(1, 2, _node.Address, tun_ta.Target, AHPacket.AHOptions.Exact, AHPacket.Protocol.Tunneling, ms.ToArray()); } #if TUNNEL_DEBUG Console.Error.WriteLine("Created a request packet."); #endif EdgeCreationState ecs = new EdgeCreationState(localid, forwarding_edges, p, ecb); _ecs_ht[localid] = ecs; #if TUNNEL_DEBUG Console.Error.WriteLine("Created an edge creation state for the tunnel edge: {0}", e); #endif } } //we will defer this sending to next heartbeat; an artificial delay from out own side } catch(Exception e) { ecb(false, null, e); } }
/// <summary>Creates an XmppEdge.</summary> public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { if(_ready == 0) { ecb(false, null, new Exception("Xmpp is not authenticated")); } XmppTransportAddress xta = ta as XmppTransportAddress; if(xta == null) { ecb(false, null, new Exception("TA Type is not Xmpp!")); return; } else if(!_xmpp.IsUserOnline(xta.JID)) { ecb(false, null, new Exception("Xmpp user, " + xta.JID + ", is not online.")); return; } XmppEdge xe = new XmppEdge(this, _local_ta, xta, false); _it.Add(xe); xe.CloseEvent += CloseHandler; ecb(true, xe, null); }
public RelayEdgeCallbackAction(RelayTransportAddress tta, EdgeCreationCallback ecb) { RelayTA = tta; Ecb = ecb; Exception = new WriteOnce<Exception>(); Success = new WriteOnce<bool>(); Edge = new WriteOnce<Edge>(); }
public EdgeCreationState(int id, IList senders, Packet p, EdgeCreationCallback ecb) { Id = id; Senders = senders; _ecb = ecb; RequestPacket = p; _r = new Random(); _attempts = MAX_ATTEMPTS; _last_send = DateTime.UtcNow; _last_send_lock = new object(); }
/** * 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); } }
public TunnelEdgeCallbackAction(TunnelTransportAddress tta, EdgeCreationCallback ecb) { TunnelTA = tta; Ecb = ecb; Exception = new WriteOnce<Exception>(); Success = new WriteOnce<bool>(); Edge = new WriteOnce<Edge>(); }
/* * 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); }
/** * It is imperative that the ECB be called and not ignored. Not * calling back will leave the system in a stale state as it waits * for the CreateEdgeTo to complete. * @param ta TransportAddress to create an edge to * @param ecb the EdgeCreationCallback to call when done * @throw EdgeException if we try to call this before calling */ public abstract void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb);
/// <summary>Does not immediately create an edge to a remote node, instead, /// it tells a timer to wait 5 seconds prior to attempting an edge.</summary> public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { TunnelTransportAddress tta = ta as TunnelTransportAddress; if(tta == null) { ecb(false, null, new Exception("TA Type is not Tunnel!")); } else { TunnelEdgeCallbackAction teca = new TunnelEdgeCallbackAction(tta, ecb); System.Action<DateTime> callback = delegate(DateTime now) { CreateEdgeTo(teca); }; Brunet.Util.FuzzyTimer.Instance.DoAfter(callback, 10000, 0); } }
public CreationState(EdgeCreationCallback ecb, Queue ipq, int port, TcpEdgeListener tel) { ECB = ecb; IPAddressQueue = ipq; Port = port; TEL = tel; Result = new WriteOnce<object>(); }
///<summary>This wraps the underlying CreateEdgeTo using EdgeCreationWrappers</summary> public override void CreateEdgeTo(TransportAddress ta, EdgeCreationCallback ecb) { EdgeCreationWrapper ecw = new EdgeCreationWrapper(ta, ecb, null, this); _el.CreateEdgeTo(ta, ecw.Callback); }
/* ////////////////////////////// * * 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); } }
/* * 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); }
/* * 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); } }