alfred/melonvpn-original-cs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: alfred:wip
Branches Tags
alfred:master
alfred:wip
alfred:old-wip-daemonmsg
..
compare: alfred:master
Branches Tags
alfred:wip
alfred:master
alfred:old-wip-daemonmsg

No commits in common. "wip" and "master" have entirely different histories.
wip ... master

4 changed files with 5 additions and 353 deletions
Show Stats Expand all files Collapse all files

341
MelonVPNCore/DaemonMessaging.cs
View File

@ -1,341 +0,0 @@
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Collections.Generic;
namespace MelonVPNCore
{
public class DaemonClient : IDisposable
{
public ClientResponseState SendDataMessage(DataMessage msg) => SendCustomMessage(Messages.GetMessage(msg));
private Socket _sock;
public static int timeout = 5000;
private Thread _recvThread;
public bool shouldBeConnected = false;
public event EventHandler<String> messageReceived;
public event EventHandler<Exception> connectionError;
public DaemonClient() { }
public DaemonClient(Socket sockIn)
{
if (sockIn is null) throw new ArgumentNullException(nameof(sockIn));
}
public void start()
{
try
{
if (_sock is null)
{
IPHostEntry host = Dns.GetHostEntry("localhost");
IPAddress ipAddress = host.AddressList[0];
IPEndPoint remoteEndPoint = new IPEndPoint(ipAddress, DaemonServer.port);
_sock = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
shouldBeConnected = true;
_sock.Connect(remoteEndPoint);
}
else
{
shouldBeConnected = true;
}
_sock.ReceiveTimeout = timeout;
_sock.SendTimeout = timeout;
_recvThread = new Thread(recvThreader)
{
IsBackground = true
};
_recvThread.Start();
}
catch (Exception e)
{
shouldBeConnected = false;
Console.WriteLine(e);
_sock = null;
if (!(_recvThread is null))
{
if (_recvThread.IsAlive) _recvThread.Abort();
_recvThread = null;
}
throw new InvalidOperationException("Daemon Client Init Failed.");
}
}
public ClientResponseState SendCustomMessage(string msg)
{
try
{
if (msg == Messages.EOF || msg == "") return ClientResponseState.Blank;
byte[] bytes = Encoding.ASCII.GetBytes(msg);
_sock.Send(bytes);
shouldBeConnected = _sock.Connected;
return ClientResponseState.Sent;
}
catch (Exception e)
{
Console.WriteLine(e);
shouldBeConnected = _sock.Connected;
connectionError?.Invoke(this, e);
return ClientResponseState.Error;
}
}
public bool poll()
{
this.SendDataMessage(DataMessage.Blank);
return shouldBeConnected;
}
public void recvThreader()
{
while (shouldBeConnected)
{
try
{
string data = null;
byte[] bytes = null;
while (shouldBeConnected)
{
bytes = new byte[1024];
int bytesRec = _sock.Receive(bytes);
data += Encoding.ASCII.GetString(bytes, 0, bytesRec);
shouldBeConnected = _sock.Connected;
if (data.IndexOf(Messages.EOF, StringComparison.CurrentCulture) > -1) break;
}
messageReceived?.Invoke(this, data);
} catch (SocketException e)
{
Console.WriteLine(e);
shouldBeConnected = _sock.Connected;
connectionError?.Invoke(this, e);
} catch (Exception e)
{
Console.WriteLine(e);
shouldBeConnected = _sock.Connected;
}
}
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
shouldBeConnected = false;
try
{
_sock.Shutdown(SocketShutdown.Both);
} catch (SocketException e)
{
Console.WriteLine(e);
}
if (!(_recvThread is null))
{
if (_recvThread.IsAlive) _recvThread.Abort();
_recvThread = null;
}
_sock.Close();
}
_sock = null;
_recvThread = null;
disposedValue = true;
}
}
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
}
#endregion
}
public class DaemonServer : IDisposable
{
public static int port = 22037;
private Socket _sock;
private Thread _lThread;
private bool _stayListening = false;
public event EventHandler<DaemonClient> clientConnected;
public void start()
{
try
{
IPHostEntry host = Dns.GetHostEntry("localhost");
IPAddress ipAddress = host.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
_sock = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_stayListening = true;
_sock.Bind(localEndPoint);
_sock.Listen(64);
_lThread = new Thread(lThreader)
{
IsBackground = true
};
_lThread.Start();
}
catch (Exception e)
{
_stayListening = false;
Console.WriteLine(e);
_sock = null;
if (!(_lThread is null))
{
if (_lThread.IsAlive) _lThread.Abort();
_lThread = null;
}
throw new InvalidOperationException("Daemon Server Init Failed.");
}
}
public void lThreader()
{
while (_stayListening)
{
try
{
DaemonClient dc = new DaemonClient(_sock.Accept());
clientConnected?.Invoke(this,dc);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_stayListening = false;
if (!(_lThread is null))
{
if (_lThread.IsAlive) _lThread.Abort();
_lThread = null;
}
_sock.Close();
}
_sock = null;
_lThread = null;
disposedValue = true;
}
}
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
}
#endregion
}
public class DaemonClientMultiplexor : IDisposable
{
public ClientResponseState SendDataMessage(DataMessage msg) => SendCustomMessage(Messages.GetMessage(msg));
private List<DaemonClient> plexed = new List<DaemonClient>();
private object slockplexed = new object();
private object slockcon = new object();
private object slockrecv = new object();
public event EventHandler<String> clientMessageReceived;
public event EventHandler<DaemonClient> clientConnectComplete;
public bool startClients = true;
public DaemonClientMultiplexor(DaemonServer dsIn)
{
if (dsIn is null) throw new ArgumentNullException(nameof(dsIn));
dsIn.clientConnected += DsIn_ClientConnected;
}
void DsIn_ClientConnected(object sender, DaemonClient e)
{
lock (slockplexed) plexed.Add(e);
e.messageReceived += E_MessageReceived;
e.connectionError += E_ConnectionError;
if (startClients) e.start();
lock(slockcon) clientConnectComplete?.Invoke(this, e);
}
void E_MessageReceived(object sender, string e)
{
lock(slockrecv) clientMessageReceived?.Invoke(this, e);
}
void E_ConnectionError(object sender, Exception e)
{
var dc = (DaemonClient)sender;
if (! dc.shouldBeConnected) { dc.Dispose(); lock (slockplexed) plexed.Remove(dc); }
}
public ClientResponseState SendCustomMessage(string msg)
{
var toret = ClientResponseState.Sent;
lock (slockplexed) {
foreach (DaemonClient c in plexed)
{
try
{
if (c.SendCustomMessage(msg) != ClientResponseState.Sent) toret = ClientResponseState.Error;
if (!c.shouldBeConnected) { c.Dispose(); lock (slockplexed) plexed.Remove(c); }
} catch (Exception e)
{
Console.WriteLine(e);
}
}
}
return toret;
}
public void disconnectAllClients()
{
lock (slockplexed) foreach (DaemonClient c in plexed) c.Dispose();
lock (slockplexed) plexed.Clear();
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
lock(slockplexed) foreach (DaemonClient c in plexed) c.Dispose();
lock (slockplexed) plexed.Clear();
}
plexed = null;
slockcon = null;
slockrecv = null;
slockplexed = null;
disposedValue = true;
}
}
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
}
#endregion
}
}

10
MelonVPNCore/DaemonSocketServer.cs
View File

@ -13,8 +13,8 @@ namespace MelonVPNCore
private static Process currentVpnProcess; private static Process currentVpnProcess;
private static bool shouldBeRunning; private static bool shouldBeRunning;
private static bool isRestarting; private static bool isRestarting;
private const int dstartingTime = 3000; private const int startingTime = 3000;
private const int drestartDelay = 250; private const int restartDelay = 250;
private static DaemonConfig config; private static DaemonConfig config;
public const string daemonConfigPath = "/etc/melon-vpn/daemon.cfg"; public const string daemonConfigPath = "/etc/melon-vpn/daemon.cfg";
@ -194,7 +194,7 @@ namespace MelonVPNCore
Console.WriteLine("Restarting embedded process"); Console.WriteLine("Restarting embedded process");
currentVpnProcess.Dispose(); currentVpnProcess.Dispose();
currentVpnProcess = null; currentVpnProcess = null;
Thread.Sleep((config.restartDelay < drestartDelay) ? drestartDelay : config.restartDelay); Thread.Sleep(restartDelay);
bool imonline = false; bool imonline = false;
isRestarting = true; isRestarting = true;
while (config.ShouldRestart && shouldBeRunning) while (config.ShouldRestart && shouldBeRunning)
@ -213,7 +213,7 @@ namespace MelonVPNCore
{ {
currentVpnProcess.Dispose(); currentVpnProcess.Dispose();
currentVpnProcess = null; currentVpnProcess = null;
Thread.Sleep((config.restartDelay < drestartDelay) ? drestartDelay : config.restartDelay); Thread.Sleep(restartDelay);
} }
} }
isRestarting = false; isRestarting = false;
@ -239,7 +239,7 @@ namespace MelonVPNCore
}; };
currentVpnProcess.Exited += CurrentVpnProcess_Exited; currentVpnProcess.Exited += CurrentVpnProcess_Exited;
currentVpnProcess.Start(); currentVpnProcess.Start();
Thread.Sleep((config.StartingTime < dstartingTime) ? dstartingTime : config.StartingTime); Thread.Sleep(startingTime);
return !currentVpnProcess.HasExited; return !currentVpnProcess.HasExited;
} }
catch (Exception e) catch (Exception e)

6
MelonVPNCore/Json.cs
View File

@ -76,11 +76,5 @@ namespace MelonVPNCore
[JsonProperty("restart")] [JsonProperty("restart")]
public bool ShouldRestart { get; set; } public bool ShouldRestart { get; set; }
[JsonProperty("starting_time")]
public int StartingTime { get; set; }
[JsonProperty("restart_delay")]
public int restartDelay { get; set; }
} }
} }

1
MelonVPNCore/MelonVPNCore.csproj
View File

@ -36,7 +36,6 @@
<Compile Include="ClientListParser.cs" /> <Compile Include="ClientListParser.cs" />
<Compile Include="ConnectedClient.cs" /> <Compile Include="ConnectedClient.cs" />
<Compile Include="Json.cs" /> <Compile Include="Json.cs" />
<Compile Include="DaemonMessaging.cs" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Reference Include="System" /> <Reference Include="System" />