Esempio n. 1
0
        /**
         * @param port the port to listen on
         * @param ipList an IEnumerable object of IPAddress objects.
         * @param ta_auth the TAAuthorizer to use for remote nodes
         */
        public TcpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
        {
            _is_started  = 0;
            _listen_sock = new Socket(AddressFamily.InterNetwork,
                                      SocketType.Stream, ProtocolType.Tcp);
            _listen_sock.LingerState = new LingerOption(true, 0);
            IPEndPoint tmp_ep = new IPEndPoint(IPAddress.Any, port);

            _listen_sock.Bind(tmp_ep);
            _local_endpoint = (IPEndPoint)_listen_sock.LocalEndPoint;
            port            = _local_endpoint.Port;
            _count          = 0;

            /**
             * We get all the IPAddresses for this computer
             */
            if (local_config_ips == null)
            {
                _tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Tcp, port);
            }
            else
            {
                _tas = TransportAddressFactory.Create(TransportAddress.TAType.Tcp, port, local_config_ips);
            }

            _ta_auth = ta_auth;
            if (_ta_auth == null)
            {
                //Always authorize in this case:
                _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
            }
            _loop = new Thread(this.SelectLoop);
            //This is how we push jobs into the SelectThread
            ActionQueue = new LockFreeQueue <SocketStateAction>();
        }
Esempio n. 2
0
        public void Test()
        {
            TAAuthorizer     a1 = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
            TransportAddress ta = TransportAddressFactory.CreateInstance("brunet.udp://127.0.0.1:45");

            Assert.IsTrue(a1.IsNotDenied(ta), "constant allow");
            TAAuthorizer a2 = new ConstantAuthorizer(TAAuthorizer.Decision.Deny);

            Assert.IsFalse(a2.IsNotDenied(ta), "constant deny");

            IPAddress    network = IPAddress.Parse("10.128.0.0");
            TAAuthorizer a3      = new NetmaskTAAuthorizer(network, 9,
                                                           TAAuthorizer.Decision.Deny,
                                                           TAAuthorizer.Decision.None);
            TransportAddress ta2 = TransportAddressFactory.CreateInstance("brunet.udp://10.255.255.255:80");

            Assert.AreEqual(a3.Authorize(ta2), TAAuthorizer.Decision.Deny, "Netmask Deny");
            TransportAddress ta3 = TransportAddressFactory.CreateInstance("brunet.udp://10.1.255.255:80");

            Assert.AreEqual(a3.Authorize(ta3), TAAuthorizer.Decision.None, "Netmask None");
            //Here is the series:
            //If Netmask doesn't say no, constant says yes:
            TAAuthorizer[] my_auths = new TAAuthorizer[] { a3, a1 };
            TAAuthorizer   a4       = new SeriesTAAuthorizer(my_auths);

            Assert.AreEqual(a4.Authorize(ta2), TAAuthorizer.Decision.Deny, "Series Deny");
            Assert.AreEqual(a4.Authorize(ta3), TAAuthorizer.Decision.Allow, "Series Allow");
        }
 public FunctionEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth)
 {
     _listener_id = id;
     _ploss_prob  = loss_prob;
     if (ta_auth == null)
     {
         _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
     }
     else
     {
         _ta_auth = ta_auth;
     }
     _tas = new ArrayList();
     _tas.Add(TransportAddressFactory.CreateInstance("brunet.function://localhost:" +
                                                     _listener_id.ToString()));
     _queue        = new BC.LFBlockingQueue <FQEntry>();
     _queue_thread = new Thread(new ThreadStart(StartQueueProcessing));
 }
Esempio n. 4
0
 public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay)
 {
     _edges       = new Dictionary <Edge, Edge>();
     _use_delay   = use_delay;
     _listener_id = id;
     _ploss_prob  = loss_prob;
     if (ta_auth == null)
     {
         _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
     }
     else
     {
         _ta_auth = ta_auth;
     }
     _tas = new ArrayList();
     _tas.Add(TransportAddressFactory.CreateInstance("b.s://" + _listener_id));
     _rand = new Random();
 }
Esempio n. 5
0
        /**
         * @param port the local port to bind to
         * @param local_tas an IEnumerable object which gives the list of local
         * IPs.  This is consulted every time LocalTAs is accessed, so it can
         * change as new interfaces are added
         * @param ta_auth the TAAuthorizer for packets incoming
         */
        public UdpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
        {
            _s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            _s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, Int32.MaxValue);
            _s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, Int32.MaxValue);
            ipep = new IPEndPoint(IPAddress.Any, port);
            _s.Bind(ipep);
            _port = port = ((IPEndPoint)(_s.LocalEndPoint)).Port;

            /**
             * We get all the IPAddresses for this computer
             */
            if (local_config_ips == null)
            {
                _tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Udp, _port);
            }
            else
            {
                _tas = TransportAddressFactory.Create(TransportAddress.TAType.Udp, _port, local_config_ips);
            }
            _nat_hist = null;
            _nat_tas  = new NatTAs(_tas, _nat_hist);
            _ta_auth  = ta_auth;
            if (_ta_auth == null)
            {
                //Always authorize in this case:
                _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
            }
            //We start out expecting around 30 edges with
            //a load factor of 0.15 (to make edge lookup fast)
            _id_ht        = new Hashtable(30, 0.15f);
            _remote_id_ht = new Hashtable();
            _sync         = new object();
            _running      = 0;
            _isstarted    = 0;
            ///@todo, we need a system for using the cryographic RNG
            _rand                     = new Random();
            _send_handler             = this;
            _listen_finished_event    = new ManualResetEvent(false);
            _listen_thread            = new Thread(ListenThread);
            _send_thread              = new Thread(SendThread);
            _send_thread.IsBackground = true;
            _send_queue               = new LFBlockingQueue <UdpMessage>();
        }
Esempio n. 6
0
 public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay)
 {
     _edges       = new Hashtable();
     _use_delay   = use_delay;
     _sync        = new object();
     _ba          = new BufferAllocator(Int16.MaxValue);
     _listener_id = id;
     _ploss_prob  = loss_prob;
     if (ta_auth == null)
     {
         _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
     }
     else
     {
         _ta_auth = ta_auth;
     }
     _tas = new ArrayList();
     _tas.Add(TransportAddressFactory.CreateInstance("b.s://" + _listener_id));
     _rand = new Random();
 }
Esempio n. 7
0
 /**
  * @param port the local port to bind to
  * @param local_tas an IEnumerable object which gives the list of local
  * IPs.  This is consulted every time LocalTAs is accessed, so it can
  * change as new interfaces are added
  * @param ta_auth the TAAuthorizer for packets incoming
  */
 public UdpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
 {
   _s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
   ipep = new IPEndPoint(IPAddress.Any, port);
   _s.Bind(ipep);
   _port = port = ((IPEndPoint) (_s.LocalEndPoint)).Port;
   /**
    * We get all the IPAddresses for this computer
    */
   if( local_config_ips == null ) {
     _tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Udp, _port);
   }
   else {
     _tas = TransportAddressFactory.Create(TransportAddress.TAType.Udp, _port, local_config_ips);
   }
   _nat_hist = null;
   _nat_tas = new NatTAs( _tas, _nat_hist );
   _ta_auth = ta_auth;
   if( _ta_auth == null ) {
     //Always authorize in this case:
     _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
   }
   //We start out expecting around 30 edges with
   //a load factor of 0.15 (to make edge lookup fast)
   _id_ht = new Hashtable(30, 0.15f);
   _remote_id_ht = new Hashtable();
   _sync = new object();
   _running = 0;
   _isstarted = 0;
   ///@todo, we need a system for using the cryographic RNG
   _rand = new Random();
   _send_handler = this;
   _listen_finished_event = new ManualResetEvent(false);
   _listen_thread = new Thread(ListenThread);
   _send_thread = new Thread(SendThread);
   _send_thread.IsBackground = true;
   _send_queue = new LFBlockingQueue<UdpMessage>();
 }
Esempio n. 8
0
 public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay)
 {
   _edges = new Hashtable();
   _use_delay = use_delay;
   _sync = new object();
   _ba = new BufferAllocator(Int16.MaxValue);
   _listener_id = id;
   _ploss_prob = loss_prob;
   if (ta_auth == null) {
     _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
   } else {
     _ta_auth = ta_auth;
   }
   _tas = new ArrayList();
   _tas.Add(TransportAddressFactory.CreateInstance("b.s://" + _listener_id));
   _rand = new Random();
 }
Esempio n. 9
0
    public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth,
        bool use_delay, TransportAddress.TAType type, INat nat)
    {
      _edges = new Dictionary<Edge, Edge>();
      _use_delay = use_delay;
      LocalID = id;
      _ploss_prob = loss_prob;
      if (ta_auth == null) {
        _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
      } else {
        _ta_auth = ta_auth;
      }
      _ta_type = type;

      Nat = nat;
      _is_started = false;
    }
Esempio n. 10
0
    /**
     * @param port the port to listen on
     * @param ipList an IEnumerable object of IPAddress objects.
     * @param ta_auth the TAAuthorizer to use for remote nodes
     */
    public TcpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
    {
      _is_started = 0;
      _listen_sock = new Socket(AddressFamily.InterNetwork,
                                SocketType.Stream, ProtocolType.Tcp);
      _listen_sock.LingerState = new LingerOption (true, 0);
      IPEndPoint tmp_ep = new IPEndPoint(IPAddress.Any, port);
      _listen_sock.Bind(tmp_ep);
      _local_endpoint = (IPEndPoint) _listen_sock.LocalEndPoint;
      port = _local_endpoint.Port;
      _count = 0;
      /**
       * We get all the IPAddresses for this computer
       */
      if( local_config_ips == null ) {
        _tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Tcp, port);
      }
      else {
        _tas = TransportAddressFactory.Create(TransportAddress.TAType.Tcp, port, local_config_ips);
      }

      _ta_auth = ta_auth;
      if( _ta_auth == null ) {
        //Always authorize in this case:
        _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
      }
      _loop = new Thread( this.SelectLoop );
      //This is how we push jobs into the SelectThread
      ActionQueue = new LockFreeQueue<SocketStateAction>();
    }
Esempio n. 11
0
 public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay)
 {
   _edges = new Dictionary<Edge, Edge>();
   _use_delay = use_delay;
   _listener_id = id;
   _ploss_prob = loss_prob;
   if (ta_auth == null) {
     _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
   } else {
     _ta_auth = ta_auth;
   }
   _tas = new ArrayList();
   _tas.Add(TransportAddressFactory.CreateInstance("b.s://" + _listener_id));
   _rand = new Random();
 }
Esempio n. 12
0
 public void Test() {
   TAAuthorizer a1 = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
   TransportAddress ta = TransportAddressFactory.CreateInstance("brunet.udp://127.0.0.1:45");
   Assert.IsTrue( a1.IsNotDenied( ta ), "constant allow");
   TAAuthorizer a2 = new ConstantAuthorizer(TAAuthorizer.Decision.Deny);
   Assert.IsFalse( a2.IsNotDenied( ta ), "constant deny");
   
   IPAddress network = IPAddress.Parse("10.128.0.0");
   TAAuthorizer a3 = new NetmaskTAAuthorizer(network, 9,
                                             TAAuthorizer.Decision.Deny,
                                             TAAuthorizer.Decision.None);
   TransportAddress ta2 = TransportAddressFactory.CreateInstance("brunet.udp://10.255.255.255:80");
   Assert.AreEqual(a3.Authorize(ta2), TAAuthorizer.Decision.Deny, "Netmask Deny");
   TransportAddress ta3 = TransportAddressFactory.CreateInstance("brunet.udp://10.1.255.255:80");
   Assert.AreEqual(a3.Authorize(ta3), TAAuthorizer.Decision.None, "Netmask None");
   //Here is the series:
   //If Netmask doesn't say no, constant says yes:
   TAAuthorizer[] my_auths = new TAAuthorizer[]{ a3, a1 };
   TAAuthorizer a4 = new SeriesTAAuthorizer(my_auths);
   Assert.AreEqual(a4.Authorize(ta2), TAAuthorizer.Decision.Deny, "Series Deny");
   Assert.AreEqual(a4.Authorize(ta3), TAAuthorizer.Decision.Allow, "Series Allow");
 }