public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol, VpnCredentials credentials) { ApplyNetworkSettings(); _origin.Connect(servers, config, protocol, credentials); }
public virtual bool Changed(VpnProtocol vpnProtocol) { bool childChanged = false; foreach (Setting child in GetChildren()) { if (child.Changed(vpnProtocol)) { childChanged = true; break; } } if (childChanged) { if (_appSettings.GetType().GetProperty(Name)?.PropertyType == typeof(bool)) { return(!_reverted); } return(true); } return(Value != GetSettingValueSerialized()); }
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol, VpnCredentials credentials) { AddDefaultGateway(); _origin.Connect(servers, config, protocol, credentials); }
public VpnState(VpnStatus status, string entryIp, VpnProtocol protocol, string label = "") { Status = status; EntryIp = entryIp; Protocol = protocol; Label = label; }
private static VpnStateChangedEventArgs Map(VpnStateContract contract) { VpnStatus status = Map(contract.Status); VpnError error = Map(contract.Error); VpnProtocol protocol = Map(contract.VpnProtocol); return(new(status, error, contract.EndpointIp, contract.NetworkBlocked, protocol, contract.OpenVpnAdapterType, contract.Label)); }
private static VpnStateChangedEventArgs Map(VpnStateContract contract) { VpnStatus status = Map(contract.Status); VpnError error = Map(contract.Error); VpnProtocol protocol = Map(contract.Protocol); return(new VpnStateChangedEventArgs(status, error, contract.EndpointIp, contract.NetworkBlocked, protocol)); }
public VpnState(VpnStatus status, string entryIp, VpnProtocol vpnProtocol, OpenVpnAdapter?networkAdapterType = null, string label = "") { Status = status; EntryIp = entryIp; NetworkAdapterType = networkAdapterType; VpnProtocol = vpnProtocol; Label = label; }
public VpnState(VpnStatus status, VpnError error, string localIp, string remoteIp, VpnProtocol protocol = VpnProtocol.Auto) { Status = status; Error = error; LocalIp = localIp; RemoteIp = remoteIp; Protocol = protocol; }
private ProtocolType MapProtocolType(VpnProtocol protocol) { if (protocol == VpnProtocol.OpenVpnTcp) { return(ProtocolType.Tcp); } return(ProtocolType.Udp); }
private static VpnProtocolContract Map(VpnProtocol protocol) { return(protocol switch { VpnProtocol.OpenVpnUdp => VpnProtocolContract.OpenVpnUdp, VpnProtocol.OpenVpnTcp => VpnProtocolContract.OpenVpnTcp, VpnProtocol.WireGuard => VpnProtocolContract.WireGuard, VpnProtocol.Smart => VpnProtocolContract.Smart, });
public VpnStateChangedEventArgs(VpnState state, VpnError error, bool networkBlocked, VpnProtocol protocol = VpnProtocol.Auto) { Ensure.NotNull(state, nameof(state)); State = state; Error = error; NetworkBlocked = networkBlocked; Protocol = protocol; }
private SocketType MapSocketType(VpnProtocol protocol) { if (protocol == VpnProtocol.OpenVpnUdp) { return(SocketType.Dgram); } return(SocketType.Stream); }
private void OnVpnProtocolChanged(VpnProtocol vpnProtocol) { bool isPreviousProtocolObfuscated; if ((isPreviousProtocolObfuscated = UserSettings.IsObfuscationProtocolEnabled(vpnProtocol)) ^ this._isPreviousProtocolObfuscated) { this.ReverseHandlersUrls(); } this._isPreviousProtocolObfuscated = isPreviousProtocolObfuscated; }
public VpnState(VpnStatus status, VpnError error, string localIp, string remoteIp, VpnProtocol vpnProtocol, OpenVpnAdapter?openVpnAdapter = null, string label = "") { Status = status; Error = error; LocalIp = localIp; RemoteIp = remoteIp; OpenVpnAdapter = openVpnAdapter; VpnProtocol = vpnProtocol; Label = label; }
public void OnAppSettingsChanged(PropertyChangedEventArgs e) { if (e.PropertyName == nameof(IAppSettings.OvpnProtocol) && _lastVpnProtocol == VpnProtocol.WireGuard && _appSettings.GetProtocol() != VpnProtocol.WireGuard || _lastVpnProtocol != VpnProtocol.WireGuard && _appSettings.GetProtocol() == VpnProtocol.WireGuard) { _updateAction.Run(); _lastVpnProtocol = _appSettings.GetProtocol(); } }
public VpnConnectionRequest( IReadOnlyList <VpnHost> servers, VpnProtocol protocol, VpnConfig config, VpnCredentials credentials) { Servers = servers; Protocol = protocol; Config = config; Credentials = credentials; }
public void Enumerable_ShouldThrow_WhenProtocolIsNotSupported(VpnProtocol protocol) { // Arrange var endpoint = new VpnEndpoint(new VpnHost("abc.com", "1.2.3.4", string.Empty), protocol, 54321); var subject = new EndpointArguments(endpoint); // Act Action action = () => subject.ToList(); // Assert action.Should().Throw <ArgumentException>(); }
public void Enumerable_ShouldMap_VpnProtocol(VpnProtocol protocol, string expected) { // Arrange var endpoint = new VpnEndpoint(new VpnHost("abc.com", "7.7.7.7", string.Empty), protocol, 44444); var subject = new EndpointArguments(endpoint); // Act var result = subject.ToList(); // Assert result.Should().Contain($"--remote {endpoint.Server.Ip} {endpoint.Port} {expected}"); }
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol, VpnCredentials credentials) { _servers = servers; _config = config; _protocol = protocol; _credentials = credentials; _connectRequested = true; _disconnectedReceived = false; Queued(Connect); }
public INetworkInterface GetByVpnProtocol(VpnProtocol vpnProtocol, OpenVpnAdapter?openVpnAdapter) { if (vpnProtocol == VpnProtocol.WireGuard) { return(GetWireGuardTunInterface()); } return(openVpnAdapter switch { OpenVpnAdapter.Tap => GetOpenVpnTapInterface(), OpenVpnAdapter.Tun => GetOpenVpnTunInterface(), _ => new NullNetworkInterface() });
private async Task Connect(IEnumerable <Server> servers, VpnProtocol protocol) { var request = new VpnConnectionRequest( Servers(servers), protocol, VpnConfig(), _vpnCredentialProvider.Credentials()); await _vpnServiceManager.Connect(request); _logger.Info("Connect requested"); _modals.CloseAll(); }
private string OpenVpnProtocol(VpnProtocol protocol) { switch (protocol) { case VpnProtocol.OpenVpnUdp: return("udp"); case VpnProtocol.OpenVpnTcp: return("tcp"); } throw new ArgumentException(nameof(protocol)); }
public override bool Changed(VpnProtocol vpnProtocol) { bool changed = base.Changed(vpnProtocol); if (_customDnsIpSetting.GetSettingValueSerialized() != _customDnsIpSetting.Value) { if (_appSettings.CustomDnsIps.Length == 0) { return(true); } } return(_appSettings.CustomDnsIps.Length != 0 && changed); }
private void ApplyNetworkSettings(VpnProtocol vpnProtocol, OpenVpnAdapter?openVpnAdapter) { uint interfaceIndex = _networkInterfaceLoader.GetByVpnProtocol(vpnProtocol, openVpnAdapter).Index; try { _logger.Info("Setting interface metric..."); NetworkUtil.SetLowestTapMetric(interfaceIndex); _logger.Info("Interface metric set."); } catch (NetworkUtilException e) { _logger.Error("Failed to apply network settings. Error code: " + e.Code); } }
public void Connect(IReadOnlyList <VpnHost> servers, VpnConfig config, VpnProtocol protocol, VpnCredentials credentials) { _reconnectPending = false; _reconnecting = false; _disconnecting = false; _protocol = protocol; _credentials = credentials; _config = config; _candidates.Set(servers); _candidates.Reset(); _endpoint = _candidates.Next(_protocol); _origin.Connect(_endpoint, credentials, config); }
private async Task <VpnEndpoint> BestEndpoint(VpnHost server, VpnProtocol protocol, CancellationToken cancellationToken) { switch (protocol) { case VpnProtocol.Auto: var bestEndpoint = await BestEndpoint(EndpointCandidates(server, VpnProtocol.OpenVpnUdp)); if (bestEndpoint.Port == 0 && !cancellationToken.IsCancellationRequested) { bestEndpoint = await BestEndpoint(EndpointCandidates(server, VpnProtocol.OpenVpnTcp)); } return(bestEndpoint); default: return(await BestEndpoint(EndpointCandidates(server, protocol))); } }
public VpnEndpoint Next(VpnProtocol protocol) { if (!string.IsNullOrEmpty(Current.Server.Ip)) { _skippedIps[protocol].Add(Current.Server.Ip); } var server = _all.FirstOrDefault(i => !_skippedIps[protocol].Contains(i.Ip)); if (server.IsEmpty()) { _skippedIps[protocol].Clear(); server = _all.FirstOrDefault(); } Current = Endpoint(server, protocol); return(Current); }
private string GetVpnProtocol(VpnProtocol protocol) { switch (protocol) { case 0: return("udp"); case 1: return("tcp"); case 2: return("xorudp"); case 3: return("xortcp"); default: throw new NotSupportedException(); } }
private void RestoreNetworkSettings(VpnProtocol vpnProtocol, OpenVpnAdapter?openVpnAdapter) { uint interfaceIndex = _networkInterfaceLoader.GetByVpnProtocol(vpnProtocol, openVpnAdapter).Index; if (interfaceIndex == 0) { return; } try { _logger.Info("Restoring interface metric..."); NetworkUtil.RestoreDefaultTapMetric(interfaceIndex); _logger.Info("Interface metric restored."); } catch (NetworkUtilException e) { _logger.Error("Failed restore network settings. Error code: " + e.Code); } }
public Task <string> GetConfigAsync(string domain, VpnProtocol protocol) { OpenVpnConfigsDownloadManager.< GetConfigAsync > d__7 <GetConfigAsync> d__;