vStationURM/Tools/KcpTunGui/KtClientGui/MainWindow.xaml.cs

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Xml;

namespace KtClientGui
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private bool _canClose;

        public MainWindow()
        {
            InitializeComponent();
            LoadProxyChannels();
            LoadConfigs();
        }

        private bool LocalPortExists(int localPort)
        {
            for (var i = 0; i < ProxyChannelList.Items.Count; i++)
            {
                var proxyChannel = ProxyChannelList.Items[i] as ClientProxyChannel;
                if (proxyChannel.LocalPort == localPort)
                {
                    return true;
                }
            }
            return false;
        }

        private bool ProxyChannelExists(string targetIp, int targetPort)
        {
            for (var i = 0; i < ProxyChannelList.Items.Count; i++)
            {
                var proxyChannel = ProxyChannelList.Items[i] as ClientProxyChannel;
                if (proxyChannel.TargetIp.ToLower() == targetIp.ToLower() && proxyChannel.TargetPort == targetPort)
                {
                    return true;
                }
            }
            return false;
        }

        private void OnAddClientProxyChannel(object sender, RoutedEventArgs e)
        {
            if (!int.TryParse(TbLocalPort.Text, out var localPort))
            {
                MessageBox.Show(this, "Invlid port value, the port value should be 0-65535.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbLocalPort.Focus();
                return;
            }
            if (localPort < 0 || localPort > 65535)
            {
                MessageBox.Show(this, "Invlid port value, the port value should be 0-65535.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbLocalPort.Focus();
                return;
            }
            if (LocalPortExists(localPort))
            {
                MessageBox.Show(this, "Proxy port already exists in the list.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbLocalPort.Focus();
                return;
            }

            var targetIp = TbTargetIp.Text;
            if (string.IsNullOrEmpty(targetIp))
            {
                MessageBox.Show(this, "Invlid IP address value.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbTargetIp.Focus();
                return;
            }
            if (!IPAddress.TryParse(targetIp, out _))
            {
                MessageBox.Show(this, "Invlid IP address value.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbTargetIp.Focus();
                return;
            }
            if (!int.TryParse(TbTargetPort.Text, out var targetPort))
            {
                MessageBox.Show(this, "Invlid port value, the port value should be 0-65535.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbTargetPort.Focus();
                return;
            }
            if (targetPort < 0 || targetPort > 65535)
            {
                MessageBox.Show(this, "Invlid port value, the port value should be 0-65535.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbTargetPort.Focus();
                return;
            }

            if (ProxyChannelExists(targetIp, targetPort))
            {
                MessageBox.Show(this, "Proxy channel already exists in the list.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                TbTargetIp.Focus();
                return;
            }

            var clientProxyChannel = new ClientProxyChannel(localPort, targetIp, targetPort);
            ProxyChannelList.Items.Add(clientProxyChannel);
            SaveBtn.IsEnabled = true;
        }

        private void OnRemoveClientProxyChannel(object sender, RoutedEventArgs e)
        {
            var button = (Button)sender;
            var clientProxyChannel = (ClientProxyChannel)button.DataContext;
            clientProxyChannel.Stop();
            ProxyChannelList.Items.Remove(clientProxyChannel);
            SaveBtn.IsEnabled = true;
        }

        private void OnStartStopProxyChannel(object sender, RoutedEventArgs e)
        {
            var button = (Button)sender;
            var clientProxyChannel = (ClientProxyChannel)button.DataContext;
            if (!clientProxyChannel.Started)
            {
                clientProxyChannel.Start();
            }
            else
            {
                clientProxyChannel.Stop();
            }
        }

        private void StartAll()
        {
            for (var i = 0; i < ProxyChannelList.Items.Count; i++)
            {
                var clientProxyChannel = ProxyChannelList.Items[i] as ClientProxyChannel;
                if (clientProxyChannel != null && !clientProxyChannel.Started)
                {
                    clientProxyChannel.Start();
                }
            }
        }

        private void StopAll()
        {
            for (var i = 0; i < ProxyChannelList.Items.Count; i++)
            {
                var clientProxyChannel = ProxyChannelList.Items[i] as ClientProxyChannel;
                if (clientProxyChannel != null && clientProxyChannel.Started)
                {
                    clientProxyChannel.Stop();
                }
            }
        }

        private void OnStartAll(object sender, RoutedEventArgs e)
        {
            StartAll();
        }

        private void OnStopAll(object sender, RoutedEventArgs e)
        {
            StopAll();
        }

        private void LoadProxyChannels()
        {
            var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ClientProxyChannels.xml");
            if (File.Exists(configFile))
            {
                var doc = new XmlDocument();
                doc.Load(configFile);
                var root = doc.SelectSingleNode("ClientProxyChannels");
                if (root != null)
                {
                    var proxyChannelNodes = root.SelectNodes("ClientProxyChannel");
                    if (proxyChannelNodes != null)
                    {
                        for (var i = 0; i < proxyChannelNodes.Count; i++)
                        {
                            var proxyChannelNode = proxyChannelNodes[i];
                            if (proxyChannelNode.Attributes != null)
                            {
                                var localPortAttr = proxyChannelNode.Attributes["localPort"];
                                if (localPortAttr != null && int.TryParse(localPortAttr.Value, out var proxyPort))
                                {
                                    if (proxyPort > 0 && proxyPort < 65535)
                                    {
                                        var targetIpAttr = proxyChannelNode.Attributes["targetIp"];
                                        if (targetIpAttr != null && IPAddress.TryParse(targetIpAttr.Value, out _))
                                        {
                                            var targetIp = targetIpAttr.Value;
                                            var targetPortAttr = proxyChannelNode.Attributes["targetPort"];
                                            if (targetPortAttr != null && int.TryParse(targetPortAttr.Value, out var targetPort))
                                            {
                                                if (targetPort > 0 && targetPort < 65535)
                                                {
                                                    var clientProxyChannel = new ClientProxyChannel(proxyPort, targetIp, targetPort);
                                                    ProxyChannelList.Items.Add(clientProxyChannel);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private void SaveProxyChannels()
        {
            var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ClientProxyChannels.xml");
            var doc = new XmlDocument();
            var root = doc.CreateElement("ClientProxyChannels");
            for (var i = 0; i < ProxyChannelList.Items.Count; i++)
            {
                var clientProxyChannel = ProxyChannelList.Items[i] as ClientProxyChannel;
                if (clientProxyChannel != null)
                {
                    var proxyChannelNode = doc.CreateElement("ClientProxyChannel");

                    var proxyPortAttr = doc.CreateAttribute("localPort");
                    proxyPortAttr.Value = clientProxyChannel.LocalPort.ToString();
                    var targetIpAttr = doc.CreateAttribute("targetIp");
                    targetIpAttr.Value = clientProxyChannel.TargetIp;
                    var targetPortAttr = doc.CreateAttribute("targetPort");
                    targetPortAttr.Value = clientProxyChannel.TargetPort.ToString();

                    proxyChannelNode.Attributes.Append(proxyPortAttr);
                    proxyChannelNode.Attributes.Append(targetIpAttr);
                    proxyChannelNode.Attributes.Append(targetPortAttr);

                    root.AppendChild(proxyChannelNode);
                }
            }
            doc.AppendChild(root);
            doc.Save(configFile);
        }

        private void LoadConfigs()
        {
            var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs.xml");
            if (File.Exists(configFile))
            {
                var doc = new XmlDocument();
                doc.Load(configFile);
                var root = doc.SelectSingleNode("Client");
                if (root != null && root.Attributes != null)
                {
                    var autoStartAttr = root.Attributes["autoStart"];
                    if (autoStartAttr != null && bool.TryParse(autoStartAttr.Value, out var autoStart))
                    {
                        CbAutoStart.IsChecked = autoStart;
                    }

                    var autoEnableAttr = root.Attributes["autoEnable"];
                    if (autoEnableAttr != null && bool.TryParse(autoEnableAttr.Value, out var autoEnable))
                    {
                        CbAutoEnable.IsChecked = autoEnable;
                        if (autoEnable)
                        {
                            StartAll();
                        }
                    }
                }
            }
        }


        private void SetAutoRunning(bool enable, string exeName, string path)
        {
            try
            {
                RegistryKey local = Registry.LocalMachine;
                RegistryKey key = local.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);
                if (key == null)
                {
                    local.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run");
                }
                if (enable)
                {
                    key.SetValue(exeName, path);
                }
                else
                {
                    var keyNames = key.GetValueNames();
                    foreach (string keyName in keyNames)
                    {
                        if (keyName.ToUpper() == exeName.ToUpper())
                        {
                            key.DeleteValue(exeName);
                        }
                    }
                }
                key.Close();
            }
            catch
            {
                //
            }
        }


        private void SaveConfigs()
        {
            var autoStart = (bool)CbAutoStart.IsChecked;

            var exePath = Process.GetCurrentProcess().MainModule.FileName;
            SetAutoRunning(autoStart, "KcpClient", exePath);

            var autoEnable = (bool)CbAutoEnable.IsChecked;
            var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs.xml");
            var doc = new XmlDocument();
            var root = doc.CreateElement("Client");
            var autoStartAttr = doc.CreateAttribute("autoStart");
            autoStartAttr.Value = autoStart.ToString();

            var autoEnableAttr = doc.CreateAttribute("autoEnable");
            autoEnableAttr.Value = autoEnable.ToString();

            root.Attributes.Append(autoStartAttr);
            root.Attributes.Append(autoEnableAttr);

            doc.AppendChild(root);
            doc.Save(configFile);
        }

        private void OnSaveClick(object sender, RoutedEventArgs e)
        {
            SaveProxyChannels();
            SaveBtn.IsEnabled = false;
        }

        private void OnAutoStartChecked(object sender, RoutedEventArgs e)
        {
            SaveConfigs();
        }

        private void OnAutoStartUnchecked(object sender, RoutedEventArgs e)
        {
            SaveConfigs();
        }

        private void OnAutoEnableChecked(object sender, RoutedEventArgs e)
        {
            SaveConfigs();
        }

        private void OnAutoEnableUnchecked(object sender, RoutedEventArgs e)
        {
            SaveConfigs();
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            e.Cancel = !_canClose;
            if (!_canClose)
            {
                Hide();
            }
            else
            {
                StopAll();
            }
            base.OnClosing(e);
        }

        protected override void OnStateChanged(EventArgs e)
        {
            if (WindowState == WindowState.Minimized)
            {
                Hide();
            }
            base.OnStateChanged(e);
        }

        private void OnTrayMouseDoubleClick(object sender, RoutedEventArgs e)
        {
            Show();
            WindowState = WindowState.Normal;
            Topmost = true;
            Activate();
            Topmost = false;

        }

        private void OnExitClick(object sender, RoutedEventArgs e)
        {
            _canClose = true;
            Close();
        }
    }
}