private bool HandleRequest()
{
if (!EventsEnabled)
{
Logging.Info("pausing events until events are reenabled");
__HoldSignal.WaitOne();
}
var line = __StreamReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
return(false);
}
IVPNResponse response = JsonConvert.DeserializeObject <IVPNResponse>(line, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
});
Logging.Info("received " + response);
switch (response.GetType().ToString())
{
case "IVPN.IVPNHelloResponse":
// Uncommment to test eror during connection to client proxy
// Thread.Sleep(2000);
// throw new Exception("This is some text exception with very long text");
Logging.Info("got hello, server version is " + ((IVPNHelloResponse)response).Version);
break;
case "IVPN.IVPNServerListResponse":
Logging.Info($"Got servers info [{((IVPNServerListResponse)response).VpnServers.OpenVPNServers.Count} openVPN; {((IVPNServerListResponse)response).VpnServers.WireGuardServers.Count} WireGuard]");
VpnServersInfo retServers = ((IVPNServerListResponse)response).VpnServers;
// When no servers received:
// - on a initialization (ServiceConnected == false): throw an exception
// - if we already initialized (servers already initialized) - just ignore this empty response
if (!retServers.OpenVPNServers.Any() || !retServers.WireGuardServers.Any())
{
if (ServiceConnected == false)
{
throw new ServersNotLoaded();
}
break;
}
VpnServerList = retServers;
ServerListChanged(VpnServerList);
if (ServiceConnected != true)
{
ServiceConnected = true; // final GUI initialization performs only after receiving servers-list
}
break;
case "IVPN.IVPNPingServersResponse":
IVPNPingServersResponse resp = (IVPNPingServersResponse)response;
Logging.Info($"Got ping response for {resp.pingResults.Count} servers");
ServersPingsUpdated(resp.pingResults);
break;
case "IVPN.IVPNStateResponse":
ConnectionState(((IVPNStateResponse)response).State, ((IVPNStateResponse)response).StateAdditionalInfo);
break;
case "IVPN.IVPNConnectedResponse":
IVPNConnectedResponse connectedRes = (IVPNConnectedResponse)response;
Connected(connectedRes.TimeSecFrom1970, connectedRes.ClientIP, connectedRes.ServerIP);
break;
case "IVPN.IVPNDisconnectedResponse":
IVPNDisconnectedResponse discRes = response as IVPNDisconnectedResponse;
Disconnected(discRes.Failure, discRes.Reason, discRes.ReasonDescription);
break;
case "IVPN.IVPNGetPreferencesResponse":
IVPNGetPreferencesResponse prefsRes = response as IVPNGetPreferencesResponse;
Preferences(prefsRes.Preferences);
break;
case "IVPN.IVPNDiagnosticsGeneratedResponse":
{
IVPNDiagnosticsGeneratedResponse diag = response as IVPNDiagnosticsGeneratedResponse;
DiagnosticsGenerated(diag);
}
break;
case "IVPN.IVPNServiceExitingResponse":
__IsExiting = true;
ServiceExiting();
break;
case "IVPN.IVPNKillSwitchGetStatusResponse":
case "IVPN.IVPNKillSwitchGetIsPestistentResponse":
case "IVPN.IVPNSetAlternateDnsResponse":
case "IVPN.IVPNEmptyResponse":
case "IVPN.IVPNErrorResponse":
__BlockingCollection.Add(response);
break;
}
return(true);
}
private bool HandleResponse()
{
if (!EventsEnabled)
{
Logging.Info("pausing events until events are reenabled");
__HoldSignal.WaitOne();
}
string line = "";
try
{
line = __StreamReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
return(false);
}
}
catch (Exception ex)
{
throw new Exception("Failed to receive command ", ex);
}
Responses.IVPNResponse response;
try
{
response = JsonConvert.DeserializeObject <Responses.IVPNResponse>(line);
Logging.Info($"received {response.Command}: {response}");
}
catch (Exception ex)
{
throw new Exception($"Failed to parse command '{line}'", ex);
}
try
{
switch (response.Command)
{
case "HelloResp":
var resp = JsonConvert.DeserializeObject <Responses.IVPNHelloResponse>(line);
NotifySessionInfo(resp.Session);
Logging.Info("got hello, server version is " + resp.Version
+ (string.IsNullOrEmpty(resp.Session.Session)?"Not logged in":"Logged in"));
break;
case "ConfigParamsResp":
DaemonParams = JsonConvert.DeserializeObject <Responses.ConfigParamsResp>(line);
break;
case "ServerListResp":
var serversResp = JsonConvert.DeserializeObject <Responses.IVPNServerListResponse>(line);
Logging.Info($"Got servers info [{serversResp.VpnServers.OpenVPNServers.Count} openVPN; {serversResp.VpnServers.WireGuardServers.Count} WireGuard]");
VpnServersInfo retServers = serversResp.VpnServers;
// When no servers received:
// - on a initialization (ServiceConnected == false): throw an exception
// - if we already initialized (servers already initialized) - just ignore this empty response
if (!retServers.OpenVPNServers.Any() || !retServers.WireGuardServers.Any())
{
if (ServiceConnected == false)
{
throw new ServersNotLoaded();
}
break;
}
VpnServerList = retServers;
ServerListChanged(VpnServerList);
if (ServiceConnected != true)
{
ServiceConnected = true; // final GUI initialization performs only after receiving servers-list
}
break;
case "PingServersResp":
var pingResp = JsonConvert.DeserializeObject <Responses.IVPNPingServersResponse>(line);
if (pingResp.PingResults != null)
{
Dictionary <string, int> results = pingResp.PingResults.ToDictionary(x => x.Host, x => x.Ping);
Logging.Info($"Got ping response for {results.Count} servers");
ServersPingsUpdated(results);
}
break;
case "VpnStateResp":
var stateResp = JsonConvert.DeserializeObject <Responses.IVPNVpnStateResponse>(line);
ConnectionState(stateResp.State, stateResp.StateAdditionalInfo);
break;
case "ConnectedResp":
var connectedRes = JsonConvert.DeserializeObject <Responses.IVPNConnectedResponse>(line);
Connected(connectedRes.TimeSecFrom1970, connectedRes.ClientIP, connectedRes.ServerIP, connectedRes.VpnType, connectedRes.ExitServerID);
AlternateDNSChanged(connectedRes.ManualDNS);
break;
case "DisconnectedResp":
var discRes = JsonConvert.DeserializeObject <Responses.IVPNDisconnectedResponse>(line);
Disconnected(discRes.Failure, discRes.Reason, discRes.ReasonDescription);
break;
case "DiagnosticsGeneratedResp":
var diagResp = JsonConvert.DeserializeObject <Responses.IVPNDiagnosticsGeneratedResponse>(line);
DiagnosticsGenerated(diagResp);
break;
case "ServiceExitingResp":
__IsExiting = true;
ServiceExiting();
break;
// :: __BlockingCollection ::
case "KillSwitchStatusResp":
var kwResp = JsonConvert.DeserializeObject <Responses.IVPNKillSwitchStatusResponse>(line);
responseReceived(kwResp);
// KillSwitch change can be requested by another client - notifying about every change
KillSwitchStatus(kwResp.IsEnabled, kwResp.IsPersistent, kwResp.IsAllowLAN, kwResp.IsAllowMulticast);
break;
case "KillSwitchGetIsPestistentResp":
var kwPers = JsonConvert.DeserializeObject <Responses.IVPNKillSwitchGetIsPestistentResponse>(line);
responseReceived(kwPers);
// KillSwitch change can be requested by another client - notifying about every change
KillSwitchStatus(null, kwPers.IsPersistent, null, null);
break;
case "SessionNewResp":
{
var snResp = JsonConvert.DeserializeObject <Responses.SessionNewResponse>(line);
if (snResp.APIStatus == (int)ApiStatusCode.Success)
{
NotifySessionInfo(snResp.Session);
NotifyAccountStatus(snResp.Session.Session, snResp.Account);
}
responseReceived(snResp);
}
break;
case "AccountStatusResp":
var accStatResp = JsonConvert.DeserializeObject <Responses.AccountStatusResponse>(line);
NotifyAccountStatus(accStatResp.SessionToken, accStatResp.Account);
responseReceived(accStatResp);
break;
case "SetAlternateDNSResp":
var dnsSetResp = JsonConvert.DeserializeObject <Responses.IVPNSetAlternateDnsResponse>(line);
responseReceived(dnsSetResp);
// DNS change can be requested by another client - notifying about every change
if (dnsSetResp.IsSuccess)
{
AlternateDNSChanged(dnsSetResp.ChangedDNS);
}
break;
case "EmptyResp":
responseReceived(JsonConvert.DeserializeObject <Responses.IVPNEmptyResponse>(line));
break;
case "ErrorResp":
responseReceived(JsonConvert.DeserializeObject <Responses.IVPNErrorResponse>(line));
break;
}
}
catch (Exception ex)
{
throw new Exception($"Failed to process '{response.Command}'", ex);
}
return(true);
}
