コード例 #1
0
ファイル: UdpChat.cs プロジェクト: kinpa200296/ITaDDP
 private void _setup()
 {
     Done = true;
     _endPoint = new IPEndPoint(IPAddress.Any, Port);
     _udpSocket = new UdpSocket();
     _udpSocket.Bind(_endPoint);
 }
コード例 #2
0
        public void Start()
        {
            buffer = new SocketBuffer(1556);
            socket = factory.Udp();

            context.Queue.Add(() =>
            {
                socket.Bind();
                socket.Receive(buffer, OnReceived);
            });
        }
コード例 #3
0
        /// <summary>
        /// Starts listening for packets from LFS.
        /// </summary>
        /// <param name="host">The host to listen to.</param>
        /// <param name="port">The port to listen on.</param>
        public void Connect(string host, int port)
        {
            ThrowIfDisposed();

            udpSocket.Bind(host, port);

            if (timeoutTimer != null)
            {
                timeoutTimer.Start();
            }
        }
コード例 #4
0
        //------------------------------------------------------------
        #region Socket管理

        private IUdpSocket CreateSocket(AddressFamily family, string host, int port)
        {
            UdpSocket socket = null;

            if (family == AddressFamily.InterNetwork)
            {
                socket = new UdpSocket(family, EnableReceiveBlock);
                socket.Bind(UdpSocket.AnyPort);
            }
            else
            {
                socket = new UdpSocket(family, EnableReceiveBlock);
                socket.Bind(UdpSocket.AnyPort);
            }

            socket.SetLocalSocket(m_IsLanOB, true);
            return(socket);
        }
コード例 #5
0
ファイル: UdpTests.cs プロジェクト: vnvizitiu/leak
        public void CanTransferDataUsingUdpSockets()
        {
            using (CompletionThread worker = new CompletionThread())
            {
                worker.Start();

                using (ManualResetEvent sync = new ManualResetEvent(false))
                {
                    IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 44556);
                    byte[]     data     = Encoding.ASCII.GetBytes("abc");

                    SocketBuffer  buffer  = new SocketBuffer(data);
                    SocketFactory factory = new SocketFactory(worker);

                    using (UdpSocket sender = factory.Udp())
                        using (UdpSocket receiver = factory.Udp())
                        {
                            sender.Bind();
                            receiver.Bind(endpoint.Port);

                            receiver.Receive(new SocketBuffer(10), received =>
                            {
                                Assert.That(received.Status, Is.EqualTo(SocketStatus.OK));
                                Assert.That(received.Count, Is.EqualTo(3));
                                Assert.That(received.Buffer.Data.Take(3), Is.EqualTo(data));

                                sync.Set();
                            });

                            sender.Send(endpoint, buffer, sent =>
                            {
                                Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK));
                                Assert.That(sent.Count, Is.EqualTo(3));
                            });
                        }

                    Assert.That(sync.WaitOne(200), Is.True);
                }
            }
        }
コード例 #6
0
        public void SendReceiveTest()
        {
            const string serverMessage = "HelloFromServer";
            const string clientMessage = "ResponseFromClient";

            IPEndPoint ep       = new IPEndPoint(IPAddress.Any, 666);
            IPEndPoint serverEp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 666);
            UdpSocket  client   = new UdpSocket();
            UdpSocket  server   = new UdpSocket();

            server.Bind(666);
            Assert.AreEqual(SocketStatus.Done, client.Connect(serverEp));

            NetPacket packet       = new NetPacket();
            NetPacket clientPacket = new NetPacket();

            packet.WriteString(serverMessage);

            // Send message to client.
            Assert.AreEqual(SocketStatus.Done, server.Send(packet, client.LocalEndpoint));

            // Read message from server.
            Assert.AreEqual(SocketStatus.Done, client.Receive(clientPacket, ref ep));
            Assert.AreEqual(serverMessage, clientPacket.ReadString());

            // Send message back to server.
            clientPacket.Clear(SerializationMode.Writing);
            clientPacket.WriteString(clientMessage);
            Assert.AreEqual(SocketStatus.Done, client.Send(clientPacket));

            // Read message from client.
            Assert.AreEqual(SocketStatus.Done, server.Receive(packet, ref ep));
            Assert.AreEqual(clientMessage, packet.ReadString());

            client.Dispose();
            server.Dispose();
            packet.Dispose();
            clientPacket.Dispose();
        }
コード例 #7
0
ファイル: Client.cs プロジェクト: jinkanhq/Margatroid.Alice
        public Client(IHub hub, IConfiguration configuration, ILogger <Server> logger, IHostApplicationLifetime appLifetime)
        {
            _hub                    = hub;
            _configuration          = configuration;
            _logger                 = logger;
            CancelSource            = new CancellationTokenSource();
            QueriedVirtualAddresses = new HashSet <IPAddress>();
            Tunnels                 = new Dictionary <IPAddress, IPEndPoint>();
            Tun = new Tun("alicetun");
            var serverAddress = IPAddress.Parse(_configuration["Client:ServerAddress"]);
            var serverPort    = int.Parse(_configuration["Client:ServerPort"]);

            ServerEndPoint = new IPEndPoint(serverAddress, serverPort);
            var listenAddress = IPAddress.Parse(_configuration["Client:ListenAddress"]);
            var listenPort    = int.Parse(_configuration["Client:ListenPort"]);

            ListenEndPoint     = new IPEndPoint(listenAddress, listenPort);
            TunnelReceiveQueue = new Queue <TunFrame>();
            TunnelSendQueue    = new Queue <TunFrame>();
            UdpSocket          = new UdpSocket();
            UdpSocket.Bind(ListenEndPoint);
        }
コード例 #8
0
ファイル: Program.cs プロジェクト: jcherrabi/OpenThreadDotNet
        private static void UDPListenerThread(IPv6Address ipAddress, ushort port)
        {
            UdpSocket receiver = new UdpSocket();

            receiver.Bind(ipAddress, port);
            IPv6EndPoint remoteIp = null;

            isUdpListenerRunning = true;

            while (isUdpListenerRunning)
            {
                if (receiver.Poll(-1, SelectMode.SelectRead))
                {
                    byte[] data    = receiver.Receive(ref remoteIp);
                    string message = Encoding.ASCII.GetString(data);
                    Console.WriteLine("\n");
                    Console.WriteLine("{0} bytes from {1} {2} {3}", message.Length, remoteIp.Address, remoteIp.Port, message);
                    Console.WriteLine(">");
                }
            }

            receiver.Close();
            receiver = null;
        }
コード例 #9
0
ファイル: UdpListener.cs プロジェクト: Wiladams/NewTOAPIA
        /// <summary>
        /// Constructor that binds this object instance to an IPEndPoint.  If you need to change 
        /// IPEndPoint dynamically, Dispose and recreate a new object.
        /// </summary>
        /// <param name="endPoint">IPEndPoint where we should be listening for IP Multicast packets.</param>
        /// <param name="TimeoutMilliseconds">Milliseconds before lack of a packet == a Network Timeout</param>
        /// <example>
        /// ...
        /// UdpReceiver mcListener = new UdpReceiver(endPoint1);
        /// mcListener.Receive(packetBuffer);
        /// mcListener.Dispose();
        ///
        /// UdpReceiver mcListener = new UdpReceiver(endPoint2);
        /// mcListener.Receive(packetBuffer);
        /// mcListener.Dispose();
        ///
        /// mcListener = null;
        /// ...
        /// </example>
        public UdpReceiver(IPEndPoint endPoint, int timeoutMilliseconds)
        {
            this.MulticastEP = endPoint;
            this.disposed = false;
            this.fSocket = null;
            externalInterface = Utility.GetLocalRoutingInterface(endPoint.Address, endPoint.Port);

            //IPAddress ipa = IPAddress.Parse("192.0.0.11");
            //int ad = (int)ipa.Address;
            //s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, ad);


            // Create the socket
            this.fSocket = new UdpSocket(endPoint.AddressFamily);


            if (Utility.IsMulticast(endPoint.Address))
            {
                // Allow multiple binds to this socket, as it will still function properly
                //  (this is only the case if it is a multicast socket.  Unicast sockets fail to
                //   receive all data on all sockets)
                //fSocket.ExclusiveAddressUse = false;
                fSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
            }

            // Bind to the socket before joining a multicast group
            IPEndPoint iep = new IPEndPoint(IPAddress.Any, endPoint.Port);
            EndPoint localEndpoint = (EndPoint)iep;
            fSocket.Bind(localEndpoint);

            try
            {
                // Join the multicast group
                // This allows the kernel to inform routers that packets meant
                // for this group should come here.
                if (Utility.IsMulticast(endPoint.Address))
                {
                    if (endPoint.AddressFamily == AddressFamily.InterNetworkV6)
                    {
                        // Join the IPv6 Multicast group
                        fSocket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
                            new IPv6MulticastOption(endPoint.Address));
                    }
                    else
                    {
                        // Join the IPv4 Multicast group
                        MulticastOption mcOption = new MulticastOption(this.MulticastEP.Address);
                        fSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, mcOption);
                        
                        // The following is hinted at by MSDN, but is wrong
                        // The SocketOptionLevel needs to be 'IP', not 'Udp'
                        //fSocket.SetSocketOption(SocketOptionLevel.Udp, SocketOptionName.AddMembership, mcOption);
                    }
                }

                // Set the timeout on the socket
                if (timeoutMilliseconds > 0)
                    fSocket.ReceiveTimeout = timeoutMilliseconds;
                //fSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, timeoutMilliseconds);

                // Make room for 80 packets plus some overhead
                //fSocket.ReceiveBufferSize = UDP.MTU * 80;
                //fSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, UDP.MTU * 80);
            }
            catch (SocketException sockex)
            {
                Console.WriteLine(sockex.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                this.Dispose();
                throw;
            }
        }
コード例 #10
0
        static void Main(string[] args)
        {
            if (args.Length != 1)
            {
                string[] ports = SerialPort.GetPortNames();
                Console.WriteLine("COM port parameter not provided.");
                Console.WriteLine("Available serial ports: ");
                foreach (var serialPort in ports)
                {
                    Console.WriteLine(serialPort);
                }
                Console.ReadKey();
                return;
            }

            StreamUART uartStream = new StreamUART(args[0]);

            ncpInterface = new NcpInterface();

            try
            {
                ncpInterface.Open(uartStream);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.ReadKey();
                return;
            }

            // NetworkingInterface.SetupInterface(ncpInterface);

            Console.Write("Networkname:");
            string networkname = Console.ReadLine();

            Console.Write("Channel:");
            byte channel = Convert.ToByte(Console.ReadLine());

            Console.Write("Masterkey:");
            string masterkey = Console.ReadLine();

            Console.Write("Panid:");
            ushort panid = Convert.ToUInt16(Console.ReadLine());

            Console.Write("Listener port:");
            ushort port = Convert.ToUInt16(Console.ReadLine());

            try
            {
                ncpInterface.Form(networkname, channel, masterkey, panid);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.ReadKey();
                return;
            }

            UdpSocket receiver = new UdpSocket();

            receiver.Bind(IPv6Address.IPv6Any, port);
            IPv6EndPoint remoteIp = null;

            while (true)
            {
                if (receiver.Poll(-1, SelectMode.SelectRead))
                {
                    byte[] data    = receiver.Receive(ref remoteIp);
                    string message = Encoding.ASCII.GetString(data);
                    Console.WriteLine("\n");
                    Console.WriteLine("{0} bytes from {1} {2} {3}", message.Length, remoteIp.Address, remoteIp.Port, message);
                    Console.WriteLine(">");
                }
            }
        }