Пример #1
0
 public void Init()
 {
     TestRuntime.AssertXcodeVersion(11, 0);
     // connect so that we can later when the report and test with it
     connectedEvent = new AutoResetEvent(false);
     reportEvent    = new AutoResetEvent(false);
     host           = NetworkResources.MicrosoftUri.Host;
     // we create a connection which we are going to use to get the availabe
     // interfaces, that way we can later test protperties of the NWParameters class.
     using (var parameters = NWParameters.CreateUdp())
         using (var endpoint = NWEndpoint.Create(host, "80"))
         {
             using (var protocolStack = parameters.ProtocolStack) {
                 var ipOptions = protocolStack.InternetProtocol;
                 ipOptions.IPSetVersion(NWIPVersion.Version4);
             }
             connection = new NWConnection(endpoint, parameters);
             connection.SetQueue(DispatchQueue.DefaultGlobalQueue);              // important, else we will get blocked
             connection.SetStateChangeHandler(ConnectionStateHandler);
             connection.Start();
             Assert.True(connectedEvent.WaitOne(20000), "Connection timed out.");
             connection.GetEstablishmentReport(DispatchQueue.DefaultGlobalQueue, (r) => {
                 report = r;
                 reportEvent.Set();
             });
             Assert.True(reportEvent.WaitOne(20000), "Connection timed out.");
         }
 }
Пример #2
0
        public void Init()
        {
            TestRuntime.AssertXcodeVersion(10, 0);
            // we want to use a single connection, since it is expensive
            connectedEvent = new AutoResetEvent(false);
            interfaces     = new List <NWInterface> ();
            host           = NetworkResources.MicrosoftUri.Host;
            // we create a connection which we are going to use to get the availabe
            // interfaces, that way we can later test protperties of the NWParameters class.
            using (var parameters = NWParameters.CreateUdp())
                using (var endpoint = NWEndpoint.Create(host, "80"))
                {
                    using (var protocolStack = parameters.ProtocolStack) {
                        var ipOptions = protocolStack.InternetProtocol;
#if NET
                        ipOptions.SetVersion(NWIPVersion.Version4);
#else
                        ipOptions.IPSetVersion(NWIPVersion.Version4);
#endif
                    }
                    connection = new NWConnection(endpoint, parameters);
                    connection.SetQueue(DispatchQueue.DefaultGlobalQueue);              // important, else we will get blocked
                    connection.SetStateChangeHandler(ConnectionStateHandler);
                    connection.Start();
                    Assert.True(connectedEvent.WaitOne(20000), "Connection timed out.");
                }
        }
Пример #3
0
    static void StartConnection(NWConnection connection)
    {
        connection.SetQueue(DispatchQueue.MainQueue);
        warn($"Start Connection on {connection.Handle} with {connection.Endpoint}");

        connection.SetStateChangeHandler((state, error) => {
            var remote = connection.Endpoint;
            var errno  = (SslStatus)(error != null ? error.ErrorCode : 0);
            switch (state)
            {
            case NWConnectionState.Waiting:
                warn($"Connect to {remote.Hostname} port {remote.Port} udp={useUdp} failed, is waiting");
                break;

            case NWConnectionState.Failed:
                warn($"Connect to {remote.Hostname} port {remote.Port} udp={useUdp} failed, error {errno}");
                break;

            case NWConnectionState.Ready:
                if (verbose)
                {
                    warn($"Connect to {remote.Hostname} port {remote.Port} udp={useUdp} succeeded");
                }
                break;

            case NWConnectionState.Cancelled:
                // Release reference
                connection = null;
                break;
            }
        });
        connection.Start();
    }
Пример #4
0
        void ConnectionStateHandler(NWConnectionState state, NWError error)
        {
            switch (state)
            {
            case NWConnectionState.Ready:
                connectedEvent.Set();
                break;

            case NWConnectionState.Cancelled:
                connection?.Dispose();
                connection = null;
                stack?.Dispose();
                stack = null;
                foreach (var o in options)
                {
                    o.Dispose();
                }
                break;

            case NWConnectionState.Invalid:
            case NWConnectionState.Failed:
                Assert.Inconclusive("Network connection could not be performed.");
                break;
            }
        }
Пример #5
0
        public void Init()
        {
            TestRuntime.AssertXcodeVersion(10, 0);
            // we want to use a single connection, since it is expensive
            connectedEvent = new AutoResetEvent(false);
            host           = "www.google.com";
            using (var parameters = NWParameters.CreateTcp())
                using (var endpoint = NWEndpoint.Create(host, "80")) {
                    connection = new NWConnection(endpoint, parameters);
                    connection.SetQueue(DispatchQueue.DefaultGlobalQueue);              // important, else we will get blocked
                    connection.SetStateChangeHandler(ConnectionStateHandler);
                    connection.Start();
                    Assert.True(connectedEvent.WaitOne(20000), "Connection timed out.");
                    stack = parameters.ProtocolStack;
                    using (var ipOptions = stack.InternetProtocol) {
                        if (ipOptions != null)
                        {
#if NET
                            ipOptions.SetVersion(NWIPVersion.Version4);
#else
                            ipOptions.IPSetVersion(NWIPVersion.Version4);
#endif
                            stack.PrependApplicationProtocol(ipOptions);
                        }
                    }
                }
        }
Пример #6
0
    static NWConnection CreateOutboundConnection(string name, string port)
    {
        NWEndpoint endpoint;

        if (bonjour)
        {
            endpoint = NWEndpoint.CreateBonjourService(name, GetServiceType(), "local");
        }
        else
        {
            endpoint = NWEndpoint.Create(name, port);
        }

        Action <NWProtocolOptions> configureTls = SetupTls();
        NWParameters parameters;

        if (useUdp)
        {
            if (useTls)
            {
                parameters = NWParameters.CreateSecureUdp(configureTls: configureTls, configureUdp: null);
            }
            else
            {
                parameters = NWParameters.CreateUdp(configureUdp: null);
            }
        }
        else
        {
            if (useTls)
            {
                parameters = NWParameters.CreateSecureTcp(configureTls: configureTls, configureTcp: null);
            }
            else
            {
                parameters = NWParameters.CreateTcp(configureTcp: null);
            }
        }

        using (NWProtocolStack protocolStack = parameters.ProtocolStack){
            if (ipv4 || ipv6)
            {
                NWProtocolOptions ipOptions = protocolStack.InternetProtocol;
                ipOptions.IPSetVersion(ipv4 ? NWIPVersion.Version4 : NWIPVersion.Version6);
            }
        }

        if (localAddr != null || localPort != null)
        {
            using (NWEndpoint localEndpoint = NWEndpoint.Create(localAddr != null ? localAddr : "::", port == null ? "0" : port))
                parameters.LocalEndpoint = localEndpoint;
        }

        var connection = new NWConnection(endpoint, parameters);

        endpoint.Dispose();
        parameters.Dispose();
        return(connection);
    }
Пример #7
0
        public void CreateSecureTcpTestDoNotSetUpTls()
        {
            var setUpProtocol = CreateConfigureProtocolHandler();

            using (var parameters = NWParameters.CreateSecureTcp(configureTls: null, configureTcp: setUpProtocol))
                using (var endpoint = NWEndpoint.Create("wwww.google.com", "80"))
                    using (var connection = new NWConnection(endpoint, parameters)) {
                        connection.SetQueue(DispatchQueue.MainQueue);
                        connection.Start();
                        configureEvent.WaitOne();
                        connection.Cancel();
                        Assert.False(secureConnectionWasSet, "Configure TLS handler was called.");
                        Assert.True(protocolConfigured, "Protocol configure handler was not called.");
                    }
        }
Пример #8
0
    static void StartSendReceiveLoop(NWConnection connection)
    {
        // Start reading from stdin
        if (!detached)
        {
            SendLoop(connection);
        }

        if (verbose)
        {
            warn("Start Receive Loop");
        }

        // Start reading from the connection
        ReceiveLoop(connection);
    }
Пример #9
0
 static void ReceiveLoop(NWConnection connection)
 {
     connection.ReceiveData(1, uint.MaxValue, (DispatchData dispatchData, NWContentContext context, bool isComplete, NWError error) => {
         Action scheduleNext = () => {
             // If the context is marked as complete, and is the final context,
             // we're read-closed.
             if (isComplete)
             {
                 if (context != null && context.IsFinal)
                 {
                     if (verbose)
                     {
                         warn("Exiting because isComplete && context.IsFinal");
                     }
                     Environment.Exit(0);
                 }
                 if (dispatchData == null)
                 {
                     if (verbose)
                     {
                         warn($"Exiting because isComplete && data == zero;  error={error}");
                     }
                     Environment.Exit(0);
                 }
             }
             if (error == null)
             {
                 ReceiveLoop(connection);
             }
         };
         if (dispatchData != null)
         {
             const int STDOUT_FILENO = 1;
             DispatchIO.Write(STDOUT_FILENO, dispatchData, DispatchQueue.MainQueue, (data, stdoutError) => {
                 if (stdoutError != 0)
                 {
                     warn("stdout write error");
                 }
                 scheduleNext();
             });
         }
         else
         {
             scheduleNext();
         }
     });
 }
 public void Init()
 {
     TestRuntime.AssertXcodeVersion(10, 0);
     // we want to use a single connection, since it is expensive
     connectedEvent = new AutoResetEvent(false);
     host           = NetworkResources.MicrosoftUri.Host;
     interfaces     = new List <NWInterface> ();
     using (var parameters = NWParameters.CreateUdp())
         using (var endpoint = NWEndpoint.Create(host, "80")) {
             connection = new NWConnection(endpoint, parameters);
             connection.SetQueue(DispatchQueue.DefaultGlobalQueue);              // important, else we will get blocked
             connection.SetStateChangeHandler(ConnectionStateHandler);
             connection.Start();
             Assert.True(connectedEvent.WaitOne(20000), "Connection timed out.");
             using (var path = connection.CurrentPath)
             {
                 path.EnumerateInterfaces(EnumerateInterfacesHandler);
             }
         }
 }
Пример #11
0
 public void SetUp()
 {
     // connect and once the connection is done, deal with the diff tests
     connectedEvent = new AutoResetEvent(false);
     host           = NetworkResources.MicrosoftUri.Host;
     // we create a connection which we are going to use to get the availabe
     // interfaces, that way we can later test protperties of the NWParameters class.
     using (var parameters = NWParameters.CreateUdp())
         using (var endpoint = NWEndpoint.Create(host, "80"))
         {
             using (var protocolStack = parameters.ProtocolStack) {
                 var ipOptions = protocolStack.InternetProtocol;
                 ipOptions.IPSetVersion(NWIPVersion.Version4);
             }
             connection = new NWConnection(endpoint, parameters);
             connection.SetQueue(DispatchQueue.DefaultGlobalQueue);              // important, else we will get blocked
             connection.SetStateChangeHandler(ConnectionStateHandler);
             connection.Start();
             Assert.True(connectedEvent.WaitOne(20000), "Connection timed out.");
         }
 }
Пример #12
0
    static void SendLoop(NWConnection connection)
    {
        const int STDIN_FILENO = 0;

        DispatchIO.Read(STDIN_FILENO, 8192, DispatchQueue.MainQueue, (DispatchData readData, int stdinError) => {
            if (stdinError != 0)
            {
                warn($"Standard input error: {stdinError}");
            }
            else if (readData == null || readData.Size == 0)
            {
                // Null data represent EOF
                // Send a "write close" on the connection, by sending
                // null data with the final message context marked as
                // complete.  Note that it is valid to send with null
                // data but a non-null context.
                connection.Send((byte [] )null, context: NWContentContext.FinalMessage, isComplete: true, callback: (NWError error) => {
                    if (error != null)
                    {
                        warn($"send error: {error.ErrorCode}");
                    }
                });
                // Stop reading from stdin, do not schedule another SendLoop
            }
            else
            {
                connection.Send(readData, context: NWContentContext.DefaultMessage, isComplete: true, callback: (NWError error) => {
                    if (error != null)
                    {
                        warn($"send error: {error.ErrorCode}");
                    }
                    else
                    {
                        // continue reading from stdin
                        SendLoop(connection);
                    }
                });
            }
        });
    }
Пример #13
0
        void ConnectionStateHandler(NWConnectionState state, NWError error)
        {
            Console.WriteLine($"State is {state} and error {error}");
            switch (state)
            {
            case NWConnectionState.Ready:
                connectedEvent.Set();
                break;

            case NWConnectionState.Cancelled:
                connection?.Dispose();
                connection = null;
                foreach (var i in interfaces)
                {
                    i.Dispose();
                }
                break;

            case NWConnectionState.Invalid:
            case NWConnectionState.Failed:
                Assert.Inconclusive("Network connection could not be performed.");
                break;
            }
        }
        public void TlsDefaults()
        {
            using (var ep = NWEndpoint.Create("www.microsoft.com", "https"))
                using (var parameters = NWParameters.CreateSecureTcp())
                    using (var queue = new DispatchQueue(GetType().FullName)) {
                        var connection = new NWConnection(ep, parameters);

                        var ready = new ManualResetEvent(false);
                        connection.SetStateChangeHandler((state, error) => {
                            Console.WriteLine(state);
                            switch (state)
                            {
                            case NWConnectionState.Cancelled:
                            case NWConnectionState.Failed:
                                // We can't dispose until the connection has been closed or it failed.
                                connection.Dispose();
                                break;

                            case NWConnectionState.Invalid:
                            case NWConnectionState.Preparing:
                            case NWConnectionState.Waiting:
                                break;

                            case NWConnectionState.Ready:
                                ready.Set();
                                break;

                            default:
                                break;
                            }
                        });

                        connection.SetQueue(queue);
                        connection.Start();

                        // Wait until the connection is ready.
                        Assert.True(ready.WaitOne(TimeSpan.FromSeconds(10)), "Connection is ready");

                        using (var m = connection.GetProtocolMetadata(NWProtocolDefinition.TlsDefinition)) {
                            var s = m.TlsSecProtocolMetadata;
                            Assert.False(s.EarlyDataAccepted, "EarlyDataAccepted");
                            Assert.That(s.NegotiatedCipherSuite, Is.Not.EqualTo(SslCipherSuite.SSL_NULL_WITH_NULL_NULL), "NegotiatedCipherSuite");
                            Assert.Null(s.NegotiatedProtocol, "NegotiatedProtocol");
                            Assert.That(s.NegotiatedProtocolVersion, Is.EqualTo(SslProtocol.Tls_1_2).Or.EqualTo(SslProtocol.Tls_1_3), "NegotiatedProtocolVersion");
                            Assert.NotNull(s.PeerPublicKey, "PeerPublicKey");

                            Assert.True(SecProtocolMetadata.ChallengeParametersAreEqual(s, s), "ChallengeParametersAreEqual");
                            Assert.True(SecProtocolMetadata.PeersAreEqual(s, s), "PeersAreEqual");

                            if (TestRuntime.CheckXcodeVersion(11, 0))
                            {
                                using (var d = s.CreateSecret("Xamarin", 128)) {
                                    Assert.That(d.Size, Is.EqualTo((nuint)128), "CreateSecret-1");
                                }
                                using (var d = s.CreateSecret("Microsoft", new byte [1], 256)) {
                                    Assert.That(d.Size, Is.EqualTo((nuint)256), "CreateSecret-2");
                                }

                                Assert.That(s.NegotiatedTlsProtocolVersion, Is.EqualTo(TlsProtocolVersion.Tls12).Or.EqualTo(TlsProtocolVersion.Tls13), "NegotiatedTlsProtocolVersion");
                                // we want to test the binding/API - not the exact value which can vary depending on the negotiation between the client (OS) and server...
                                Assert.That(s.NegotiatedTlsCipherSuite, Is.Not.EqualTo(0), "NegotiatedTlsCipherSuite");
                                Assert.That(s.ServerName, Is.EqualTo("www.microsoft.com"), "ServerName");
                                // we don't have a TLS-PSK enabled server to test this
                                Assert.False(s.AccessPreSharedKeys((psk, pskId) => { }), "AccessPreSharedKeys");
                            }
                        }

                        connection.Cancel();
                    }
        }
Пример #15
0
    static NWListener CreateAndStartListener(string host, string port)
    {
        Action <NWProtocolOptions> configureTls = SetupTls();
        NWParameters parameters;

        // Create the parameters, either TLS or no TLS, and with UDP or no UDP
        if (useUdp)
        {
            if (useTls)
            {
                parameters = NWParameters.CreateSecureUdp(configureTls: configureTls, configureUdp: null);
            }
            else
            {
                parameters = NWParameters.CreateUdp(configureUdp: null);
            }
        }
        else
        {
            if (useTls)
            {
                parameters = NWParameters.CreateSecureTcp(configureTls: configureTls, configureTcp: null);
            }
            else
            {
                parameters = NWParameters.CreateTcp(configureTcp: null);
            }
        }

        // If specified, set the IP version
        using (NWProtocolStack protocolStack = parameters.ProtocolStack){
            if (ipv4 || ipv6)
            {
                NWProtocolOptions ipOptions = protocolStack.InternetProtocol;
                ipOptions.IPSetVersion(ipv4 ? NWIPVersion.Version4 : NWIPVersion.Version6);
            }
        }

        // Bind to local address and port
        string address = bonjour ? null : host;

        if (address != null || port != null)
        {
            NWEndpoint localEndpoint = NWEndpoint.Create(address != null ? address : "::", port != null ? port : "0");
            Console.WriteLine("Getting {0} and {1}", address != null ? address : "::", port != null ? port : "0");
            parameters.LocalEndpoint = localEndpoint;
            Console.WriteLine("With port: " + localEndpoint.Port);
        }

        var listener = NWListener.Create(parameters);

        if (bonjour && host != null)
        {
            listener.SetAdvertiseDescriptor(NWAdvertiseDescriptor.CreateBonjourService(host, GetServiceType(), "local"));
            listener.SetAdvertisedEndpointChangedHandler((NWEndpoint advertisedEndpoint, bool added) => {
                if (verbose)
                {
                    var astr = added ? "added" : "removed";
                    warn($"Listener {astr} on {advertisedEndpoint.BonjourServiceName} on ({advertisedEndpoint.BonjourServiceName}.{GetServiceType()}.local");
                }
            });
        }

        listener.SetQueue(DispatchQueue.MainQueue);
        listener.SetStateChangedHandler((listenerState, error) => {
            var errno = (SslStatus)(error == null ? 0 : error.ErrorCode);
            switch (listenerState)
            {
            case NWListenerState.Waiting:
                if (verbose)
                {
                    warn($"Listener on port {listener.Port} udp={useUdp} waiting");
                }
                break;

            case NWListenerState.Failed:
                warn($"Listener on port {listener.Port} udp={useUdp} failed");
                break;

            case NWListenerState.Ready:
                if (verbose)
                {
                    warn($"Listener on port {listener.Port} udp={useUdp} ready");
                }
                break;

            case NWListenerState.Cancelled:
                listener = null;
                break;
            }
        });

        listener.SetNewConnectionHandler((connection) => {
            if (inboundConnection != null)
            {
                // We only support one connection at a time, so if we already
                // have one, reject the incoming connection.
                connection.Cancel();
            }
            else
            {
                if (verbose)
                {
                    warn($"New Connection on {connection.Handle} with {connection.Endpoint}");
                }
                // Accept the incoming connection and start sending  and receiving on it
                inboundConnection = connection;
                StartConnection(inboundConnection);
                StartSendReceiveLoop(inboundConnection);
            }
        });
        listener.Start();

        return(listener);
    }
Пример #16
0
 public iOSWifiService()
 {
     var conn = new NWConnection(new IntPtr(), true);
 }