Ejemplo n.º 1
0
        public MainPageViewModel(IServiceProvider serviceProvider, AppViewModel appViewModel)
            : base(serviceProvider, appViewModel)
        {
            m_connectionInfoProperty           = CreateDictionaryProperty(() => ConnectionInfo, () => null);
            m_connectionInfoTaskStatusProperty = CreateDictionaryProperty(() => ConnectionInfoTaskStatus, () => TaskStatus.Created);
            m_dhcpInfoProperty                  = CreateDictionaryProperty(() => DhcpInfo, () => null);
            m_dhcpInfoTaskStatusProperty        = CreateDictionaryProperty(() => DhcpInfoTaskStatus, () => TaskStatus.Created);
            m_externalAddressProperty           = CreateDictionaryProperty(() => ExternalAddress, () => null);
            m_externalAddressTaskStatusProperty = CreateDictionaryProperty(() => ExternalAddressTaskStatus, () => TaskStatus.Created);
            m_statusProperty                  = CreateDictionaryProperty(() => Status, () => String.Empty);
            m_progressPercentProperty         = CreateDictionaryProperty(() => ProgressPercent, () => 0.0d);
            m_isScanInProgressProperty        = CreateDictionaryProperty(() => IsScanInProgress, () => false);
            m_customSelectionCommandsProperty = CreateDictionaryProperty(() => CustomSelectionCommands, () => new ObservableCollection <UICommand>());
            m_startAddressValueProperty       = CreateSettingsProperty(V1SettingsConstants.StartAddressValueKey, () => StartAddressValue, () => 0u, () => { UpdateActionBarControls(); });
            m_isStartAddressValidProperty     = CreateDictionaryProperty(() => IsStartAddressValid, () => false);
            m_endAddressValueProperty         = CreateSettingsProperty(V1SettingsConstants.EndAddressValueKey, () => EndAddressValue, () => 0u, () => { UpdateActionBarControls(); });
            m_isEndAddressValidProperty       = CreateDictionaryProperty(() => IsEndAddressValid, () => false);

            var hostInfoService = ServiceProvider.GetService <IHostInfoService>();
            var hostInfo        = hostInfoService.GetCurrentHostInfo();

            if (hostInfo == null)
            {
                Status = Strings.Status_GetHostInfoFailed;
            }
            else
            {
                var connectionInfoTask  = RunGetConnectionInfoAsync(hostInfo);
                var dhcpInfoTask        = RunGetDhcpInfoAsync(hostInfo);
                var externalAddressTask = RunGetExternalAddressAsync();

                Task.Factory.ContinueWhenAll(new[] { connectionInfoTask, dhcpInfoTask }, t =>
                {
                    if (ConnectionInfo != null)
                    {
                        if (DhcpInfo != null && DhcpInfo.DnsServerAddress != null)
                        {
                            m_dnsResolver = new UdpDnsResolver(
                                new DnsResolverOptions(),
                                new DatagramSocketFactory(),
                                new IPEndpoint(DhcpInfo.DnsServerAddress, Constants.DefaultDnsPort));
                        }

                        SetAddressValues(ConnectionInfo.Network);

                        IsScanInProgress       = false;
                        m_isScanCommandEnabled = true;
                        m_scanCommand.Refresh();
                        m_isCancelScanCommandEnabled = false;
                        m_cancelScanCommand.Refresh();
                    }
                },
                                             CancellationToken.None,
                                             TaskContinuationOptions.None,
                                             TaskScheduler.FromCurrentSynchronizationContext());
            }

            m_scanCommand = new DelegateCommand(async() =>
            {
                var scanStopwatch = new Stopwatch();
                scanStopwatch.Start();

                m_tokenSource = new CancellationTokenSource();

                AvailableServices.Clear();

                IsScanInProgress       = true;
                m_isScanCommandEnabled = false;
                m_scanCommand.Refresh();
                m_isCancelScanCommandEnabled = true;
                m_cancelScanCommand.Refresh();

                Status = Strings.Status_ScanStarted;

                var selectedAddresses = new IPAddressRange(StartAddressValue, EndAddressValue);
                var networkServices   = await GetNetworkServicesAsync();

                var index    = 0;
                var progress = (IProgress <ScanNetworkBatch>) new Progress <ScanNetworkBatch>(batch =>
                {
                    foreach (var result in batch.Results)
                    {
                        if (result.IsAvailable)
                        {
                            AvailableServices.Add(result);
                        }
                    }
                    index          += batch.Results.Count;
                    ProgressPercent = 100.0d * index / (selectedAddresses.Count * networkServices.Length);
                });

                var task = Task.Factory.StartNew(
                    arg => { Scanner.ScanNetwork(m_tokenSource.Token, m_dnsResolver, selectedAddresses, networkServices, progress); },
                    m_tokenSource.Token,
                    TaskCreationOptions.None);
                var t1 = task.ContinueWith(t =>
                {
                    IsScanInProgress       = false;
                    m_isScanCommandEnabled = true;
                    m_scanCommand.Refresh();
                    m_isCancelScanCommandEnabled = false;
                    m_cancelScanCommand.Refresh();

                    var isCancelled = m_tokenSource.Token.IsCancellationRequested;
                    if (isCancelled)
                    {
                        Status          = Strings.Status_ScanCancelled;
                        ProgressPercent = 0.0d;
                    }
                    else
                    {
                        scanStopwatch.Stop();
                        var timeSpan    = scanStopwatch.Elapsed;
                        Status          = Strings.Format_Status_ScanCompleted(timeSpan);
                        ProgressPercent = 100.0d;
                    }

                    m_tokenSource.Dispose();
                },
                                           CancellationToken.None,
                                           TaskContinuationOptions.None,
                                           TaskScheduler.FromCurrentSynchronizationContext());
            },
                                                () => m_isScanCommandEnabled);

            m_cancelScanCommand = new DelegateCommand(() =>
            {
                m_isCancelScanCommandEnabled = false;
                m_cancelScanCommand.Refresh();

                m_tokenSource.Cancel();
            },
                                                      () => m_isCancelScanCommandEnabled);

            m_showServicesCommand = new DelegateCommand(() =>
            {
                AppViewModel.NavigateToServicesPage();
            });

            m_launchUriCommand = new DelegateCommand <IPEndpoint>(endpoint =>
            {
                AppViewModel.NavigateToBrowserPage(endpoint);
            });
        }
Ejemplo n.º 2
0
            public void Test_IQUERY_UDP()
            {
                var sendToInvoked  = false;
                var receiveInvoked = false;
                var disposeInvoked = false;

                var datagramSocketFactory = new MockDatagramSocketFactory(
                    (data, endpoint) =>
                {
                    Assert.IsNotNull(data);
                    data.ShouldEqual(ExpectedSendData);
                    Assert.AreEqual("192.168.11.1", endpoint.Address.ToString());
                    Assert.AreEqual((ushort)53, endpoint.Port);

                    Assert.IsFalse(sendToInvoked);
                    Assert.IsFalse(receiveInvoked);
                    Assert.IsFalse(disposeInvoked);
                    sendToInvoked = true;
                },
                    buffer =>
                {
                    Assert.IsNotNull(buffer);
                    Assert.AreEqual(512, buffer.Length);

                    Assert.IsTrue(sendToInvoked);
                    Assert.IsFalse(receiveInvoked);
                    Assert.IsFalse(disposeInvoked);

                    Array.Copy(ReceivedData, buffer, ReceivedData.Length);
                    var result     = ReceivedData.Length;
                    receiveInvoked = true;
                    return(result);
                },
                    () =>
                {
                    Assert.IsTrue(sendToInvoked);
                    Assert.IsTrue(receiveInvoked);
                    Assert.IsFalse(disposeInvoked);
                    disposeInvoked = true;
                });

                var options = new DnsResolverOptions
                {
                    Timeout    = 1000,
                    RetryCount = 3,
                    Recursion  = true,
                    UseCache   = true
                };
                var resolver = new UdpDnsResolver(
                    options,
                    datagramSocketFactory,
                    new IPEndpoint(IPAddress.Parse("192.168.11.1"), 53), new Random(0));

                var response = resolver.Query("167.11.168.192.in-addr.arpa", QType.PTR, QClass.IN);

                Assert.AreEqual(0, response.Error.Length);

                Assert.AreEqual(1, response.header.ANCOUNT);
                Assert.AreEqual(1, response.Answers.Count);

                var answerRR = response.Answers.First();

                Assert.AreEqual("167.11.168.192.in-addr.arpa.", answerRR.NAME);
                Assert.AreEqual(0u, answerRR.TTL);
                Assert.AreEqual(Class.IN, answerRR.Class);
                Assert.AreEqual(Lanscan.Networking.Dns.RecordType.PTR, answerRR.Type);
                Assert.IsInstanceOfType(answerRR.RECORD, typeof(PTRRecord));
                var recordPtr = (PTRRecord)answerRR.RECORD;

                Assert.AreEqual("alpha.example.com.", recordPtr.PTRDNAME);

                Assert.IsTrue(sendToInvoked);
                Assert.IsTrue(receiveInvoked);
                Assert.IsTrue(disposeInvoked);
            }