Example #1
0
        static private bool CreateAndConnectToProxyAsync(BaseProxyServer item)
        {
            bool statusChanged = false;

            if (!NetConnUtils.IsConnected(item))
            {
                if (NetConnUtils.IsActiveConnectionPresent())
                {
                    NetConnUtils.CloseAllActiveConnections(false);
                }
                if (NetConnUtils.IsConnectionEntryExist(item) == false)
                {
                    if (item.IsProtocolAvailable(ProxyProtocolTypeEnum.PPTP))
                    {
                        NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.PPTP);
                    }
                    else if (item.IsProtocolAvailable(ProxyProtocolTypeEnum.L2TP))
                    {
                        NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.L2TP);
                    }
                    else
                    {
                        throw new ArgumentException(VpnSelectorLibRes.Non_PPTP_no_L2TP_protocols_available_for_this_vpn_entry);
                    }
                }
                NetConnUtils.OpenConnect(item);
                //DotRasUtils.CurrentProxyServer = item;
                statusChanged = true;
            }
            return(statusChanged);
        }
Example #2
0
        static public void ConfirmIpAddressAsync()
        {
            BackgroundWorker worker = new BackgroundWorker();

            worker.DoWork += (wSender, doWorkEvent) =>
            {
                try
                {
                    NetConnUtils.ConfirmIPAddress(NetConnUtils.CurrentProxyServer, null, new JobLog());
                }
                catch (Exception ex)
                {
                    Log.LogError(ex);
                }
            };
            worker.RunWorkerCompleted += (wSender, runWorkerCompletedEvent) =>
            {
                try
                {
                    if (runWorkerCompletedEvent.Cancelled == false)
                    {
                        if (OnNetworkChekComplatedEvent != null)
                        {
                            NetworkChekComplatedEventArgs e = new NetworkChekComplatedEventArgs();
                            OnNetworkChekComplatedEvent(null, e);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            worker.RunWorkerAsync();
        }
Example #3
0
        static private void watcher_Disconnected(object sender, RasConnectionEventArgs e)
        {
            // A connection has disconnected successfully.
            Log.ProcessDebug("Event " + VpnSelectorLibRes.A_connection_has_disconnected_successfully_ + e.Connection.EntryName);

            if (VpnDisconnectedEvent != null)
            {
                VpnDisconnectedEvent(null, new VpnDisconnectedEventArgs());
            }
            if (IsSynchMode == false)
            {
                AppManager.Instance.ProcessNotification(VpnSelectorLibRes.VPN_disconnected);
                BaseProxyServer oldProxy = NetConnUtils.CurrentProxyServer;
                NetConnUtils.CurrentProxyServer = null;
                if (oldProxy != null)
                {
                    //proxy changed
                    NetConnUtils.ConfirmIpAddressAsync();
                }
                //reconnect
                //https://stackoverflow.com/questions/23950702/reconnect-vpn-windows-service
                if (NetConnUtils.CurrentProxyServer != null && IsReconnect == true)
                {
                    OpenConnectLocal(NetConnUtils.CurrentProxyServer, true);
                }
            }
        }
Example #4
0
        static private void watcher_Connected(object sender, RasConnectionEventArgs e)
        {
            // A connection has successfully connected.
            Log.ProcessDebug("Event " + VpnSelectorLibRes.A_connection_has_successfully_connected_ + e.Connection.EntryName);

            BaseProxyServer oldProxy = NetConnUtils.CurrentProxyServer;

            if (IsSynchMode == false)
            {
                NetConnUtils.CurrentProxyServer = BaseProxyServer.FindFromNames(NetConnUtils.GetActiveConnectionsNames());
            }
            if (VpnConnectedEvent != null)
            {
                VpnConnectedEvent(null, new VpnConnectedEventArgs());
            }
            if (IsSynchMode == false)
            {
                if ((oldProxy == null && NetConnUtils.CurrentProxyServer != null) ||
                    (oldProxy != null && oldProxy != NetConnUtils.CurrentProxyServer))
                {
                    //proxy changed
                    NetConnUtils.ConfirmIpAddressAsync();
                }
            }
        }
Example #5
0
 private void VpnNotifyIcon_DoubleClick(object sender, EventArgs e)
 {
     try
     {
         NetConnUtils.ConnectOrDisconnectDefautBaseProxyServerAsync();
     }
     catch (Exception ex)
     {
         Log.ShowError(ex);
     }
 }
Example #6
0
 static public bool DisconnectWithConfirmation(BaseProxyServer item, string homeIP, bool createdNew, JobLog jobLog)
 {
     if (NetConnUtils.IsActiveConnectionPresent())
     {
         NetConnUtils.CloseAllActiveConnections(false);
         Thread.Sleep(2 * 1000);
     }
     if (createdNew)
     {
         NetConnUtils.RemoveConnectionEntry(item);
     }
     return(true);
 }
Example #7
0
 private void VpnButton_MouseDown(object sender, MouseEventArgs e)
 {
     if (e.Clicks > 1)
     {
         try
         {
             NetConnUtils.ConnectOrDisconnectDefautBaseProxyServerAsync();
         }
         catch (Exception ex)
         {
             Log.ShowError(ex);
         }
     }
 }
Example #8
0
        private void VpnNotifyIconContextMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            try
            {
                e.Cancel = false;
                //vpnNotifyIcon.ContextMenuStrip.Items.Clear();
                vpnNotifyIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());

                List <ToolStripItem> subitems = new List <ToolStripItem>();
                NetConnUtils.MakeDefaultContextMenu(subitems);
                NetConnUtils.MakeFavoriteContextMenu(subitems);
                NetConnUtils.MakeContextMenuForAllBaseProxyServers(subitems);
                vpnNotifyIcon.ContextMenuStrip.Items.AddRange(subitems.ToArray());
            }
            catch (Exception ex)
            {
                Log.ShowError(ex);
            }
        }
Example #9
0
        static public bool ConnectOrDisconnectDefautBaseProxyServerAsync()
        {
            bool statusChanged = false;

            if (NetConnUtils.IsActiveConnectionPresent())
            {
                NetConnUtils.CloseAllActiveConnections(true);
                statusChanged = true;
            }
            else
            {
                BaseProxyServer item = GetDefaulBaseProxyServer();
                if (item != null)
                {
                    statusChanged = CreateAndConnectToProxyAsync(item);
                }
                else
                {
                    MessageBox.Show(VpnSelectorLibRes.Double_click_on_this_icon_creates_VPN_connection_to_default_VPN_server_which_not_set__No_connection_created_, VpnSelectorLibRes.Warning_, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            return(statusChanged);
        }
Example #10
0
        private static void ScheduleJobChekVpnServer(BaseProxyServer item, string homeIP)
        {
            JRunningJob job = null;

            job        = JobManager.Instance.CreateJob("ChekVpn", VpnSelectorLibRes.Test_for_VPN_server, item.Url, JobConcurrentTypeEnum.Wait);
            job.DoJob += (sd, ew) =>
            {
                job.JobLog.Info("Plan VPN server test for " + item.Url);
                bool res = NetConnUtils.ConnectWithConfirmation(item, homeIP, job.JobLog);
                Thread.Sleep(5 * 1000);
                job.JobLog.Info("End VPN server test for " + item.Url);
                JobManager.Instance.ReportProgresJob(job, 100);
                if (res)
                {
                    ew.StageResult = RunningJobResultEnum.ok;
                }
                else
                {
                    ew.StageResult = RunningJobResultEnum.error;
                }
            };
            item.JRunningJob = job;
            Dm.Instance.SaveObject(item);
        }
Example #11
0
        static public void MakeContextMenuForAllBaseProxyServers(List <ToolStripItem> items)
        {
            ToolStripMenuItem menuItem = new ToolStripMenuItem();

            menuItem.Text = VpnSelectorLibRes.Disconnect_from_active_VPN_connection;
            if (!NetConnUtils.IsActiveConnectionPresent())
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    NetConnUtils.CloseAllActiveConnections(true);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);


            menuItem        = new ToolStripMenuItem();
            menuItem.Text   = VpnSelectorLibRes.Show_created_VPN_entries_info;
            menuItem.Click += (s, em) =>
            {
                try
                {
                    MessageBox.Show(NetConnUtils.ShowConnectionEntries());
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);
            menuItem      = new ToolStripMenuItem();
            menuItem.Text = VpnSelectorLibRes.Show_active_VPN_connection_info;
            if (!NetConnUtils.IsActiveConnectionPresent())
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    MessageBox.Show(NetConnUtils.ShowActiveConnections());
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);


            menuItem        = new ToolStripMenuItem();
            menuItem.Text   = VpnSelectorLibRes.Delete_all_VPN_entries;
            menuItem.Click += (s, em) =>
            {
                try
                {
                    DialogResult res = MessageBox.Show(null, VpnSelectorLibRes.Delete_VPN_entries__Press__Yes__to_delete_,
                                                       FrwCRUDRes.WARNING, MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                    if (res == DialogResult.Yes)
                    {
                        if (NetConnUtils.IsActiveConnectionPresent())
                        {
                            NetConnUtils.CloseAllActiveConnections(true);
                        }
                        NetConnUtils.RemoveAllConnectionEntry();
                    }
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);
        }
Example #12
0
        static public void MakeContextMenuForBaseProxyServer(List <ToolStripItem> items, BaseProxyServer item)
        {
            ToolStripMenuItem menuItem = new ToolStripMenuItem();

            menuItem.Text = VpnSelectorLibRes.Create_VPN_entry_ + " PPTP " + item.GetConnectionName();
            if (NetConnUtils.IsConnectionEntryExist(item) || item.IsProtocolAvailable(ProxyProtocolTypeEnum.PPTP) == false)
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.PPTP);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);

            menuItem      = new ToolStripMenuItem();
            menuItem.Text = VpnSelectorLibRes.Create_VPN_entry_ + " L2TP " + item.GetConnectionName();
            if (NetConnUtils.IsConnectionEntryExist(item) || item.IsProtocolAvailable(ProxyProtocolTypeEnum.L2TP) == false)
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.L2TP);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);

            menuItem      = new ToolStripMenuItem();
            menuItem.Text = VpnSelectorLibRes.Connect_to_VPN_server;
            if (NetConnUtils.IsConnected(item))
            {
                menuItem.Enabled = false;
            }
            if (NetConnUtils.IsConnectionEntryExist(item))
            {
                menuItem.Text = menuItem.Text + VpnSelectorLibRes.__created_;
            }
            menuItem.Text   = menuItem.Text + " " + item.GetConnectionName();
            menuItem.Click += (s, em) =>
            {
                try
                {
                    DialogResult res = DialogResult.Cancel;
                    if (NetConnUtils.IsActiveConnectionPresent())
                    {
                        res = MessageBox.Show(VpnSelectorLibRes.Active_VPN_connection_found____
                                              + NetConnUtils.ShowConnectionEntries() + VpnSelectorLibRes.__Press_OK_to_close_it_and_connect_to_selected_VPN_server_, VpnSelectorLibRes.Warning_, MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
                        if (res == DialogResult.OK)
                        {
                            NetConnUtils.CloseAllActiveConnections(false);
                        }
                    }
                    else
                    {
                        res = DialogResult.OK;
                    }

                    if (res == DialogResult.OK)
                    {
                        bool statusChanged = CreateAndConnectToProxyAsync(item);
                    }
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);


            menuItem      = new ToolStripMenuItem();
            menuItem.Text = VpnSelectorLibRes.Disonnect_from_VPN_server_ + item.GetConnectionName();
            if (!NetConnUtils.IsConnected(item))
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    NetConnUtils.CloseConnect(item, true);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);

            menuItem      = new ToolStripMenuItem();
            menuItem.Text = VpnSelectorLibRes.Set_as_default_VPN_connection_ + item.GetConnectionName();
            if (NetConnUtils.GetDefaulBaseProxyServer() == item)
            {
                menuItem.Enabled = false;
            }
            menuItem.Click += (s, em) =>
            {
                try
                {
                    BaseProxyServerDefault = item;
                    JSetting setting = FrwConfig.Instance.GetProperty(DEFAULT_JPROXY_SERVER);
                    setting.Value = item;
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            items.Add(menuItem);
        }
Example #13
0
        static public void ConfirmIPAddress(BaseProxyServer item, string homeIP, JobLog jobLog)
        {
            string externalIP = NetConnUtils.GetMyExternalIP();

            if (externalIP == null)
            {
                throw new Exception("Ip of vpn connection is null");
            }
            jobLog.Info("ExternalIP: " + externalIP);
            if (homeIP != null)
            {
                if (homeIP.Equals(externalIP))
                {
                    throw new Exception("Ip address of vpn connection not changed. It equals home ip address.");
                }
            }
            JIPAddressInfo extIPAddressInfo = NetConnUtils.GetIPAddressInfo(externalIP);

            if (extIPAddressInfo == null)
            {
                throw new Exception("IPAddressInfo of vpn connection is null");
            }
            jobLog.Info("New IP address Info: " + Log.PropertyList(extIPAddressInfo));
            if (item != null)
            {
                if (item.JCountry != null)
                {
                    if (!string.IsNullOrEmpty(extIPAddressInfo.CountryCode))
                    {
                        if (extIPAddressInfo.CountryCode.ToLower().Equals(item.JCountry.JCountryId) == false)
                        {
                            //throw new Exception
                            jobLog.Warn("Country code of vpn connection ip address (" +
                                        extIPAddressInfo.CountryCode.ToLower() + ") not equals to contry code of VPN server ("
                                        + item.JCountry.JCountryId + ")");

                            JCountry newContry = Dm.Instance.Find <JCountry>(extIPAddressInfo.CountryCode.ToLower());
                            if (newContry != null)
                            {
                                if (item.JCountryDeclared == null)
                                {
                                    item.JCountryDeclared = item.JCountry;
                                }
                                item.JCountry = newContry;
                                Dm.Instance.SaveObject(item);
                            }
                            else
                            {
                                throw new Exception("Country code of vpn connection ip address (" +
                                                    extIPAddressInfo.CountryCode.ToLower() + ") not a valid country code");
                            }
                        }
                    }
                    else
                    {
                        throw new Exception("Country code of vpn connection is empty");
                    }
                    if (!string.IsNullOrEmpty(extIPAddressInfo.City))
                    {
                        if (item.Town != null)
                        {
                            if (extIPAddressInfo.City.ToLower().Equals(item.Town.ToLower()) == false)
                            {
                                jobLog.Warn("City vpn connection ip address (" +
                                            extIPAddressInfo.City + ") not equals to town of VPN server ("
                                            + item.Town + "). New City value was set");
                                if (item.TownDeclared == null)
                                {
                                    item.TownDeclared = item.Town;
                                }
                                item.Town = extIPAddressInfo.City;
                                Dm.Instance.SaveObject(item);
                            }
                        }
                        else
                        {
                            item.Town = extIPAddressInfo.City;
                            Dm.Instance.SaveObject(item);
                        }
                    }
                }
                else
                {
                    //todo
                }
                jobLog.Info("Test OK for item " + item.JProxyServerId);
            }
            //ok

            //todo
            NetConnUtils.MyExternalIP       = externalIP;
            NetConnUtils.MyExtIPAddressInfo = extIPAddressInfo;
        }
Example #14
0
        static public bool ConnectWithConfirmationLocal(BaseProxyServer item, string homeIP, out bool createdNew, JobLog jobLog)
        {
            bool result = false;

            jobLog.Debug("Start VpnServerConnectWithFullTestLocal for item " + item.JProxyServerId);
            createdNew = false;
            int closeAttemptCount = 0;

            while (NetConnUtils.IsActiveConnectionPresent())
            {
                if (closeAttemptCount > 10)
                {
                    throw new Exception("Unable to close previous active connection");
                }
                jobLog.Debug("Found previous active connection. Going to close it");
                NetConnUtils.CloseAllActiveConnections(false);
                Thread.Sleep(2 * 1000);//!!!
                closeAttemptCount++;
            }
            ///////test
            if (homeIP != null)
            {
                string externalIP = NetConnUtils.GetMyExternalIP();
                if (externalIP == null)
                {
                    throw new Exception("Ip of default connection is null");
                }
                jobLog.Info("Default ExternalIP: " + externalIP);
                if (!homeIP.Equals(externalIP))
                {
                    throw new Exception("Ip address of default connection not equals home ip address.");
                }
            }
            //////////
            if (NetConnUtils.IsConnectionEntryExist(item) == false)
            {
                if (item.IsProtocolAvailable(ProxyProtocolTypeEnum.PPTP))
                {
                    NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.PPTP);
                    createdNew = true;
                }
                else if (item.IsProtocolAvailable(ProxyProtocolTypeEnum.L2TP))
                {
                    NetConnUtils.CreateConnectionEntry(item, ProxyProtocolTypeEnum.L2TP);
                    createdNew = true;
                }
                else
                {
                    throw new ArgumentException(VpnSelectorLibRes.Non_PPTP_no_L2TP_protocols_available_for_this_vpn_entry);
                }
            }
            try
            {
                NetConnUtils.OpenConnectLocal(item, false); //sync

                Thread.Sleep(2 * 1000);                     //!!!
                //for (int i = 0; i < 60; i++)//~ 1 min
                //{
                if (NetConnUtils.IsConnected(item))
                {
                    ConfirmIPAddress(item, homeIP, jobLog);
                    result               = true;
                    item.SuccessCount    = item.SuccessCount + 1;
                    item.LastSuccessDate = DateTimeOffset.Now;
                    Dm.Instance.SaveObject(item);
                }
                else
                {
                    jobLog.Info("Not connected for item " + item.JProxyServerId);
                }
                //Thread.Sleep(1 * 1000);
                //}
                //todo error event
            }
            finally {
                //change label
                if (OnNetworkChekComplatedEvent != null)
                {
                    NetworkChekComplatedEventArgs e = new NetworkChekComplatedEventArgs();
                    OnNetworkChekComplatedEvent(null, e);
                }
            }
            return(result);
        }
Example #15
0
        override protected void MakeContextMenu(List <ToolStripItem> menuItemList, object selectedListItem, object selectedObject, string aspectName)
        {
            base.MakeContextMenu(menuItemList, selectedListItem, selectedObject, aspectName);
            menuItemList.Add(new ToolStripSeparator());

            BaseProxyServer      item     = (BaseProxyServer)selectedObject;
            List <ToolStripItem> subitems = new List <ToolStripItem>();

            NetConnUtils.MakeContextMenuForBaseProxyServer(subitems, item);
            NetConnUtils.MakeContextMenuForAllBaseProxyServers(subitems);
            menuItemList.AddRange(subitems.ToArray());

            ToolStripMenuItem groupItem = null;
            ToolStripMenuItem menuItem  = null;

            menuItem        = new ToolStripMenuItem();
            menuItem.Text   = VpnSelectorLibRes.Import_VPN_servers_from_vpngate_net;
            menuItem.Click += (s, em) =>
            {
                try
                {
                    VpngateImporter.DowloadAndParse();
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            menuItemList.Add(menuItem);


            groupItem      = new ToolStripMenuItem();
            groupItem.Text = VpnSelectorLibRes.Run_test;
            menuItemList.Add(groupItem);

            if (item != null)
            {
                menuItem        = new ToolStripMenuItem();
                menuItem.Text   = ((SelectedObjects.Count > 1) ? VpnSelectorLibRes.Run_test_for_selected_VPN_servers : VpnSelectorLibRes.Run_test_for_this_VPN_server);
                menuItem.Click += (s, em) =>
                {
                    try
                    {
                        ScheduleJobChekVpnAll(SelectedObjects, false, false);
                    }
                    catch (Exception ex)
                    {
                        Log.ShowError(ex);
                    }
                };
                groupItem.DropDownItems.Add(menuItem);

                if (item.JRunningJob != null && item.JRunningJob.JJobType != null)//JRunningJob.JJobType = null for manualy deleted job
                {
                    List <ToolStripItem> subitems2 = new List <ToolStripItem>();
                    JobManager.MakeTitleContextMenuForRunningJob(item.JRunningJob, subitems2, this.ContentContainer);
                    groupItem.DropDownItems.AddRange(subitems2.ToArray <ToolStripItem>());
                }
                if (currQueueJobType != null)
                {
                    List <ToolStripItem> subitems22 = new List <ToolStripItem>();
                    JobManager.MakeTitleContextMenuForRunningJobTypeQueue(currQueueJobType, subitems22, this.ContentContainer);
                    groupItem.DropDownItems.AddRange(subitems22.ToArray <ToolStripItem>());
                }
            }
            menuItem        = new ToolStripMenuItem();
            menuItem.Text   = VpnSelectorLibRes.Run_test_for_favorite_VPN_servers;
            menuItem.Click += (s, em) =>
            {
                try
                {
                    ScheduleJobChekVpnAll(null, false, true);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            groupItem.DropDownItems.Add(menuItem);
            menuItem        = new ToolStripMenuItem();
            menuItem.Text   = VpnSelectorLibRes.Run_test_for_all_VPN_servers;
            menuItem.Click += (s, em) =>
            {
                try
                {
                    ScheduleJobChekVpnAll(null, true, false);
                }
                catch (Exception ex)
                {
                    Log.ShowError(ex);
                }
            };
            groupItem.DropDownItems.Add(menuItem);
        }
Example #16
0
        protected void CreateVPNSupport()
        {
            NetConnUtils.InitSettings();

            //
            // vpnButton
            //
            this.vpnButton = new System.Windows.Forms.ToolStripSplitButton();
            this.vpnButton.DisplayStyle          = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
            this.vpnButton.Enabled               = true;
            this.vpnButton.ImageTransparentColor = System.Drawing.Color.Magenta;
            this.vpnButton.Name        = "vpnButton";
            this.vpnButton.Size        = new System.Drawing.Size(19, 23);
            this.vpnButton.Text        = "VPN";
            this.vpnButton.ToolTipText = "VPN";
            vpnButton.Image            = VpnSelectorLibRes.network_off;
            //vpnButton.DoubleClick += VpnButton_DoubleClick; - do not working

            //
            // ipAddressLabel
            //
            this.ipAddressLabel             = new System.Windows.Forms.ToolStripStatusLabel();
            this.ipAddressLabel.AutoToolTip = true;
            this.ipAddressLabel.Enabled     = false;
            this.ipAddressLabel.Name        = "ipAddressLabel";
            this.ipAddressLabel.Size        = new System.Drawing.Size(66, 20);
            this.ipAddressLabel.Text        = "127.0.0.1";
            this.ipAddressLabel.ToolTipText = "127.0.0.1";

            this.statusBar.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
                this.eventWarrningButton, this.vpnButton, this.ipAddressLabel
            });

            if (useMainTrayIconForVPN && BaseApplicationContext.NotifyIcon != null)
            {
                vpnNotifyIcon = BaseApplicationContext.NotifyIcon;
            }
            else
            {
                vpnNotifyIcon = new NotifyIcon(components)
                {
                    ContextMenuStrip = new ContextMenuStrip(),
                    Icon             = vpnOffIcon,
                    Text             = "VPN",
                    Visible          = true
                };
            }

            vpnButton.MouseDown += VpnButton_MouseDown;
            vpnNotifyIcon.ContextMenuStrip.Opening += VpnNotifyIconContextMenuStrip_Opening;
            vpnNotifyIcon.DoubleClick += VpnNotifyIcon_DoubleClick;

            NetConnUtils.OnNetworkChekComplatedEvent += JustNetworkUtils_OnNetworkChekComplatedEvent;
            NetConnUtils.VpnDisconnectedEvent        += VpnSelector_OnVpnDisconnectedEvent;
            NetConnUtils.VpnConnectedEvent           += VpnSelector_OnVpnConnectedEvent;
            NetConnUtils.VpnDialerErrorEvent         += VpnSelector_OnVpnDialerErrorEvent;

            NetConnUtils.CreateDialerAndBeginWatch();
            bool _isActiveConnectionPresent = NetConnUtils.IsActiveConnectionPresent();

            if (_isActiveConnectionPresent)
            {
                NetConnUtils.CurrentProxyServer = BaseProxyServer.FindFromNames(NetConnUtils.GetActiveConnectionsNames());
                ProcessVpnConnectedEvent();
                //DotRasUtils.CurrentProxyServer = DotRasUtils.CurrentProxyServer;
            }
            else
            {
                NetConnUtils.ConfirmIpAddressAsync();
            }
        }
Example #17
0
        private void ScheduleJobChekVpnAll(IList selectedItems, bool all, bool favoritOnly)
        {
            StartRefreshing();
            // create background tasks, which nevertheless are executed sequentially
            // it would be possible to create one background thread and perform all the tasks sequentially,
            // but at the same time the opportunity to destroy the hanging task is lost and to let the others continue
            // todo worth thinking about limiting the number of waiting threads

            //prepare task list
            IList list = null;

            if (all)
            {
                list = Dm.Instance.FindAll(BaseProxyServer.CurrentType);
            }
            else if (favoritOnly)
            {
                IList list0 = Dm.Instance.FindAll(BaseProxyServer.CurrentType);
                list = new List <BaseProxyServer>();
                foreach (var n in list0)
                {
                    BaseProxyServer m = (BaseProxyServer)n;
                    if (m.Favorite)
                    {
                        list.Add(m);
                    }
                }
            }
            else
            {
                list = selectedItems;
            }
            if (list == null || list.Count == 0)
            {
                throw new Exception("No items to test found");
            }

            //check for allready running tasks and stop it
            bool foundWorking = false;

            foreach (var n in list)
            {
                BaseProxyServer m = (BaseProxyServer)n;
                if (m.JRunningJob != null && m.JRunningJob.JJobType != null && m.JRunningJob.IsWorking())
                {
                    foundWorking = true;
                    break;
                }
            }
            if (foundWorking)
            {
                DialogResult res = MessageBox.Show(VpnSelectorLibRes.Running_job_found__They_will_be_aborted_or_press__Cancel__to_exit, FrwConstants.WARNING, MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
                if (res == DialogResult.Cancel)
                {
                    return;
                }
            }
            foreach (var n in list)
            {
                BaseProxyServer m = (BaseProxyServer)n;
                if (favoritOnly == false || m.Favorite)
                {
                    if (m.JRunningJob != null)
                    {
                        if (m.JRunningJob.JJobType != null)
                        {
                            if (m.JRunningJob.IsWorking())
                            {
                                JobManager.Instance.AbortJob(m.JRunningJob);
                            }
                            else
                            {
                                //m.JRunningJob.Stage = RunningJobStageEnum.initial.ToString();
                                //Dm.Instance.SaveObject(m.JRunningJob);
                            }
                        }
                        m.JRunningJob = null;
                        Dm.Instance.SaveObject(m);
                    }
                }
            }
            string homeIP = null;

            //close active vpns
            if (NetConnUtils.IsActiveConnectionPresent())
            {
                NetConnUtils.CloseAllActiveConnections(false);
                homeIP = NetConnUtils.GetMyExternalIP();
            }
            else
            {
                homeIP = NetConnUtils.MyExternalIP;
            }

            //Schedule tasks
            foreach (var n in list)
            {
                BaseProxyServer m = (BaseProxyServer)n;
                ScheduleJobChekVpnServer(m, homeIP);
                JobManager.ScheduleJobToQueue(m.JRunningJob);
                currQueueJobType = m.JRunningJob.JJobType;
            }
            if (currQueueJobType != null)
            {
                currQueueJobType.RemoveAllPostJobBatchEventHandlers();
                currQueueJobType.PostJobBatch += currQueueJobType.StandartPostLJobBatchEventHandler;
                JobManager.StartProcessingJobBatch(currQueueJobType);
            }
        }