private void WaitForVpnThreadToFinish()
{
if (vpnThread == null)
{
return;
}
try
{
vpnThread.Join(THREAD_MAX_JOIN_TIME);
}
catch (Java.Lang.InterruptedException)
{
EddieLogger.Error("VPNService.WaitVpnThreadToFinish(): VPN thread has been interrupted");
}
finally
{
if (vpnThread.IsAlive)
{
EddieLogger.Error("VPNService.WaitVpnThreadToFinish(): VPN thread did not end");
}
else
{
EddieLogger.Info("VPN thread execution has completed");
}
}
}
public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
StartCommandResult result = StartCommandResult.Sticky;
bool?run = null;
if (intent != null)
{
if (intent.GetBooleanExtra(PARAM_START, false))
{
EddieLogger.Debug("VPNService.OnStartCommand: START");
run = true;
}
else if (intent.GetBooleanExtra(PARAM_STOP, false))
{
EddieLogger.Debug("VPNService.OnStartCommand: STOP");
run = false;
}
}
else
{
EddieLogger.Debug("VPNService.OnStartCommand (no intent)");
}
if (run != null)
{
UpdateService(run.Value, intent.GetBundleExtra(EXTRA_RUN_ARGS));
}
return(result);
}
private void DoRun()
{
OpenVPNClient client = null;
lock (clientSync)
{
if (openVPNClient == null)
{
string errMsg = "OpenVPNTunnel::DoRun(): OpenVPN client is not initialized";
EddieLogger.Error(errMsg);
throw new Exception(errMsg);
}
client = openVPNClient;
// Do NOT call m_client.Start under m_clientSync'lock
}
// Dispatcher must be instantiated before starting to allow handling stop requests from outside while the client isn't started yet
// RunDispatcher();
NativeMethods.EddieLibraryResult result = client.Start();
if (result.code != NativeMethods.ResultCode.SUCCESS)
{
string errMsg = string.Format("OpenVPNTunnel::DoRun(): Failed to start OpenVPN client. {0}", result.description);
EddieLogger.Error(errMsg);
throw new Exception(errMsg);
}
}
private void LoadApplications(string appList)
{
List <string> selectedPackages = new List <string>();
string[] valArray = appList.Split(SettingsManager.DEFAULT_SPLIT_SEPARATOR);
foreach (string item in valArray)
{
selectedPackages.Add(item);
}
applicationList.Clear();
IList <ApplicationInfo> applications = base.PackageManager.GetInstalledApplications(global::Android.Content.PM.PackageInfoFlags.MetaData);
foreach (ApplicationInfo app in applications)
{
ApplicationItem item = new ApplicationItem(this, app);
item.Selected = selectedPackages.Contains(app.PackageName);
try
{
item.Icon = app.LoadIcon(PackageManager);
}
catch (System.Exception e)
{
EddieLogger.Error(e);
}
applicationList.Add(item);
}
applicationList.Sort((a, b) => a.Title.CompareTo(b.Title));
}
public NativeMethods.ovpn3_transport_stats GetTransportStats()
{
lock (clientSync)
{
if (openVPNClient == null)
{
string errMsg = "OpenVPNTunnel::GetTransportStats(): OpenVPN client is not initialized";
EddieLogger.Error(errMsg);
throw new Exception(errMsg);
}
NativeMethods.ovpn3_transport_stats stats = new NativeMethods.ovpn3_transport_stats();
NativeMethods.EddieLibraryResult result = openVPNClient.GetTransportStats(ref stats);
if (result.code != NativeMethods.ResultCode.SUCCESS)
{
string errMsg = string.Format("OpenVPNTunnel::GetTransportStats(): Failed to get OpenVPN transport stats. {0}", result.description);
EddieLogger.Error(errMsg);
throw new Exception(errMsg);
}
return(stats);
}
}
public override void OnCreate()
{
base.OnCreate();
if (!m_initialized)
{
EddieLogger.Init(this);
EddieLogger.Info("Initializing eddie library");
EddieLogger.Info("{0} - {1}", NativeMethods.EddieLibrary.LibraryQualifiedName(), NativeMethods.EddieLibrary.LibraryReleaseDate());
EddieLogger.Info("Eddie Library API level {0}", NativeMethods.EddieLibrary.LibraryApiLevel());
NativeMethods.EddieLibraryResult result = NativeMethods.EddieLibrary.Init();
if (result.code == NativeMethods.ResultCode.SUCCESS)
{
m_initialized = true;
EddieLogger.Info("Eddie Library: OpenVPN initialization succeeded");
}
else
{
EddieLogger.Error("Eddie Library: OpenVPN initialization failed. {0}", result.description);
}
}
}
public VPNManager(Context context)
{
m_context = context;
EddieLogger.Init(context);
supportTools = new SupportTools(m_context);
}
public void HandleThreadException(Exception e)
{
EddieLogger.Error(e);
LastError = e.Message;
DoStop();
}
public override void OnRevoke()
{
EddieLogger.Error("VPNService.OnRevoke");
// Another VPN may have started here or Android is shutting down the VPN: by now there is no way to "block" the operation and the service must be stopped gracefully
UpdateService(false);
base.OnRevoke();
}
public void SetMTU(int mtu)
{
if (forceMTU)
{
EddieLogger.Debug("MTU forced (value '{0}' will be skipped)", mtu);
}
else
{
vpnServiceBuilder.SetMtu(mtu);
}
}
public void AddDNSServer(string address, int ipv6)
{
if (customDNS)
{
EddieLogger.Debug("DNS forced (address '{0}' will be skipped)", address);
}
else
{
DoAddDNS(address);
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
EddieLogger.Init(this);
title = Intent.GetStringExtra(CHOOSER_TITLE);
LoadApplications(Intent.GetStringExtra(PARAM_PACKAGES));
InitUI();
}
public override void OnCreate()
{
base.OnCreate();
EddieLogger.Init(this);
Init();
networkStatusReceiver = new NetworkStatusReceiver();
networkStatusReceiver.AddListener(this);
this.RegisterReceiver(networkStatusReceiver, new IntentFilter(Android.Net.ConnectivityManager.ConnectivityAction));
}
private void OnConnectSessionStop()
{
EddieLogger.Debug("OnConnectSessionStop");
try
{
OnConnectSessionStopImpl();
}
catch (Exception e)
{
EddieLogger.Error("OnConnectSessionStop", e);
}
}
private void DoSetOption(string option, string value)
{
NativeMethods.EddieLibraryResult result = openVPNClient.SetOption(option, value);
if (result.code != NativeMethods.ResultCode.SUCCESS)
{
string errMsg = String.Format("OpenVPNTunnel::DoSetOption(): Failed to set option '{0}' with value '{1}'. {2}", option, value, result.description);
EddieLogger.Error(errMsg);
throw new Exception(errMsg);
}
}
private void OnConnectAttach()
{
EddieLogger.Debug("OnConnectAttach");
try
{
OnConnectAttachImpl();
}
catch (Exception e)
{
EddieLogger.Error("OnConnectAttach", e);
}
}
private void OnTunBuilderTeardown(/*bool*/ int disconnect)
{
EddieLogger.Debug("OnTunBuilderTeardown(disconnect={0})", disconnect);
try
{
OnTunBuilderTeardownImpl(disconnect);
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderTeardown", e);
}
}
private void OnTunBuilderEstablishLite()
{
EddieLogger.Debug("OnTunBuilderEstablishLite");
try
{
OnTunBuilderEstablishLiteImpl();
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderEstablishLite", e);
}
}
private void OnConnectRun()
{
EddieLogger.Debug("OnConnectRun");
try
{
OnConnectRunImpl();
}
catch (Exception e)
{
EddieLogger.Error("OnConnectRun", e);
}
}
public void Stop()
{
try
{
SendStopMessage();
}
catch (Exception e)
{
EddieLogger.Error(e);
OnStatusChanged(null, null, e.Message);
}
}
private void TryRestoreLastProfile(Context context)
{
EddieLogger.Debug("EddieBroadcastReceiver.TryRestoreLastProfile");
if (VPNService.Prepare(context.ApplicationContext) != null)
{
EddieLogger.Debug("VPNService.Prepare requires confirmation");
return;
}
if (!settingsManager.SystemRestoreLastProfile)
{
EddieLogger.Debug("EddieBroadcastReceiver: SystemRestoreLastProfile disabled");
return;
}
if (!settingsManager.SystemLastProfileIsConnected)
{
EddieLogger.Debug("EddieBroadcastReceiver: SystemLastProfileIsConnected false");
return;
}
string lastProfile = settingsManager.SystemLastProfile;
if (SupportTools.Empty(lastProfile))
{
EddieLogger.Debug("EddieBroadcastReceiver: lastProfile is empty");
return;
}
EddieLogger.Debug("EddieBroadcastReceiver: restoring last profile");
try
{
Bundle args = new Bundle();
args.PutString(VPNService.PARAM_PROFILE, lastProfile);
Intent intent = new Intent(context, typeof(VPNService));
intent.PutExtra(VPNService.PARAM_START, true);
intent.PutExtra(VPNService.EXTRA_RUN_ARGS, args);
context.StartService(intent);
}
catch (Exception e)
{
EddieLogger.Error("TryRestoreLastProfile", e);
}
}
public VPNContext(VPNService service)
{
vpnServiceBuilder = new VPNService.Builder(service);
vpnServiceBuilder.SetConfigureIntent(service.CreateConfigIntent());
EddieLogger.Init(service);
InitDNS();
InitMTU();
InitApplications();
}
private void ClearContexts()
{
EddieLogger.Debug("ClearContexts");
lock (contextsSync)
{
while (m_contexts.Count > 0)
{
EddieLogger.Debug("Disposing context");
SupportTools.SafeDispose(m_contexts.Pop());
}
}
}
private void DoAddDNS(string address)
{
address = address.Trim();
if (SupportTools.Empty(address))
{
throw new Exception("Invalid DNS server");
}
EddieLogger.Debug("Adding DNS server '{0}'", address);
vpnServiceBuilder.AddDnsServer(address);
hasDNS = true;
}
private int OnTunBuilderSetProxyAutoConfigUrl(string url)
{
EddieLogger.Debug("OnTunBuilderSetProxyAutoConfigUrl(url={0})", url);
try
{
return(OnTunBuilderSetProxyAutoConfigUrlImpl(url));
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderSetProxyAutoConfigUrl", e);
}
return(NativeMethods.ERROR);
}
private int OnTunBuilderSetProxyHttps(string host, int port)
{
EddieLogger.Debug("OnTunBuilderSetProxyHttps(host={0}, port={1})", host, port);
try
{
return(OnTunBuilderSetProxyHttpsImpl(host, port));
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderSetProxyHttps", e);
}
return(NativeMethods.ERROR);
}
private int OnTunBuilderAddWinsServer(string address)
{
EddieLogger.Debug("OnTunBuilderAddWinsServer(address={0})", address);
try
{
return(OnTunBuilderAddWinsServerImpl(address));
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderAddWinsServer", e);
}
return(NativeMethods.ERROR);
}
private int OnTunBuilderSetAdapterDomainSuffix(string name)
{
EddieLogger.Debug("OnTunBuilderSetAdapterDomainSuffix(name={0})", name);
try
{
return(OnTunBuilderSetAdapterDomainSuffixImpl(name));
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderSetAdapterDomainSuffix", e);
}
return(NativeMethods.ERROR);
}
private int OnTunBuilderEstablish()
{
EddieLogger.Debug("OnTunBuilderEstablish");
try
{
return(OnTunBuilderEstablishImpl());
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderEstablish", e);
}
return(NativeMethods.ERROR);
}
private int OnTunBuilderPersist()
{
EddieLogger.Debug("OnTunBuilderPersist");
try
{
return(OnTunBuilderPersistImpl());
}
catch (Exception e)
{
EddieLogger.Error("OnTunBuilderPersist", e);
}
return(NativeMethods.ERROR);
}
