/// <summary>
/// Implementation for <see cref="SaveCommand" />.
/// Creates the project.
/// </summary>
private void SaveImpl()
{
// Path verification
var file = new FileInfo(Path);
if (!Directory.Exists(file.DirectoryName))
{
Directory.CreateDirectory(file.DirectoryName);
}
// TODO: Save plot, according to settings - QuadTree stuff...
//if (this.ShowAllData)
var encoder = new PngPlotModelEncoder();
var size = new Size(Width, Height);
if (DPI.Equals(96))
{
encoder.SaveImage(this.plot, Path, size);
}
else
{
encoder.SaveImageHighRes(this.plot, Path, size, dpi);
}
if (this.Complete != null)
{
this.Complete(this, EventArgs.Empty);
}
}
public override int GetHashCode()
{
return(DPI.GetHashCode() ^
PollRate.GetHashCode() ^
ShowLastMouseMove.GetHashCode() ^
ShowVelocityAndGain.GetHashCode());
}
public override int GetHashCode()
{
return(DPI.GetHashCode() ^
PollRate.GetHashCode() ^
ShowLastMouseMove.GetHashCode() ^
ShowVelocityAndGain.GetHashCode() ^
AutoWriteToDriverOnStartup.GetHashCode());
}
public ActionResult DPI(int?id)
{
var model = new DPI();
Patient patient = db.Patients.Find(id);
if (patient == null)
{
return(HttpNotFound());
}
model.patient = patient;
model.consultation = db.Consultations.Where(x => x.ID_Patient == id).ToList();
return(View(model));
}
public MainWindow()
{
InitializeComponent();
DPI.GetDefault(this);
setting = Application.Current.LoadSetting();
FontFamily = setting.FontFamily;
Title = $"{Title} [Version: {Application.Current.Version()}]";
SearchBox.ItemsSource = AutoSuggestList;
#region Themem Init.
CommandToggleTheme.ItemsSource = Application.Current.GetAccentColorList();
CommandToggleTheme.SelectedIndex = Application.Current.GetAccentIndex();
#endregion
#region DatePicker Init.
DatePicker.DisplayMode = CalendarMode.Month;
DatePicker.FirstDayOfWeek = DayOfWeek.Monday;
DatePicker.IsTodayHighlighted = true;
DatePicker.SelectedDate = DateTime.Now;
DatePicker.DisplayDate = DateTime.Now;
DatePicker.DisplayDateStart = new DateTime(2007, 09, 11);
DatePicker.DisplayDateEnd = DateTime.Now;
DatePicker.Language = System.Windows.Markup.XmlLanguage.GetLanguage(System.Globalization.CultureInfo.CurrentCulture.IetfLanguageTag);
#endregion
#if DEBUG
CommandAttachMetaFolder.Show();
CommandMaintainDetailPage.Show();
#else
CommandAttachMetaFolder.Hide();
CommandMaintainDetailPage.Hide();
#endif
Contents = new Pages.TilesPage()
{
Name = "CategoryTiles", FontFamily = FontFamily
};
Content = Contents;
NavPageTitle.Text = Contents.TargetPage.ToString();
LastWindowStates.Enqueue(WindowState.Normal);
CreateNamedPipeServer();
}
/// <summary>
/// Initializes the application.
/// </summary>
public static void Initialize()
{
//Initialize configuration
Config.Initialize();
//Initialize Counters
CPU.GetUsage();
Memory.GetTotalSize();
DPI.CalculateDPI();
//Initialize subsystems
ClusterManager.Initialize();
Loader.Initialize();
Executor.Initialize();
//Start the server listening thread
ControlServer.Start();
ControlServer.RegisterDispatchAction(MessageType.STATUS_TERMINAL, status);
//Initialize the Node Listing
Nodes.Initialize();
}
public static int GetResolution(DPI dpi)
{
switch (dpi)
{
case DPI.DPI_72:
return(75);
case DPI.DPI_96:
return(96);
case DPI.DPI_150:
return(150);
case DPI.DPI_300:
return(300);
default:
return(150);
}
}
private void ReceivePayloadCallback(IAsyncResult ar)
{
NetworkPayload networkPayload = (NetworkPayload)ar.AsyncState;
SocketError error = SocketError.AccessDenied;
int received = 0;
try
{
//even tho there is "out error" it can still throw a error
received = Handle.EndReceive(ar, out error);
}
catch { }
if (received <= 0 || error != SocketError.Success)
{
Client.Disconnect(DisconnectReason.UnexpectedlyDisconnected);
return;
}
BytesIn += (ulong)received;
this.LastPacketSW = Stopwatch.StartNew();
networkPayload.WriteOffset += (uint)received;
if (networkPayload.WriteOffset == networkPayload.PacketSize && networkPayload.ReceivedHeader)
{
uint Offset = 0;
uint length = (uint)networkPayload.Payload.Length;
//let's check the payload hash
if (networkPayload.Header.Hash != networkPayload.Header.HashPayload(networkPayload.Payload, (int)Offset, (int)length, HandshakeChecksum))
{
Client.Disconnect(DisconnectReason.DataModificationDetected);
return;
}
//decrypt, decompress, de-cache the data we received
networkPayload.Payload = protection.RemoveProtection(networkPayload.Payload, ref Offset, ref length, ref networkPayload.Header);
IMessage message = null;
try
{
message = messageHandler.HandleMessage(new PayloadReader(networkPayload.Payload), networkPayload.Header.MessageId);
}
catch
{
}
networkPayload.syncObject.Value = networkPayload.Callback(message);
networkPayload.syncObject.Pulse();
return; //no need to read futher
}
if (!networkPayload.ReceivedHeader && networkPayload.ReceivedPacket)
{
try
{
networkPayload.ReceivedHeader = true;
//wopEncryption.Decrypt(networkPayload.Payload, 0, HEADER_SIZE);
networkPayload.Header = new PacketHeader(networkPayload.Payload, 0, this);
if (!DPI.Inspect(networkPayload.Header))
{
Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
return;
}
networkPayload.PacketSize = networkPayload.Header.PacketSize;
networkPayload.Payload = new byte[networkPayload.Header.PacketSize];
networkPayload.WriteOffset = 0; //just reset offset for reading
}
catch
{
Client.Disconnect(DisconnectReason.UnexpectedlyDisconnected);
return;
}
}
if (networkPayload.WriteOffset != networkPayload.PacketSize)
{
Handle.BeginReceive(networkPayload.Payload, (int)networkPayload.WriteOffset, (int)(networkPayload.PacketSize - networkPayload.WriteOffset), SocketFlags.None, out error, ReceivePayloadCallback, networkPayload);
}
}
private unsafe void networkStreamCallback(Network.NetworkStream stream)
{
lock (stream)
{
bool DataAvailable = true;
while (DataAvailable)
{
switch (this.stream.ReceiveState)
{
case ReceiveType.Header:
{
if (stream.CanRead(HEADER_SIZE))
{
byte[] headerData = new byte[HEADER_SIZE];
if (stream.Read(ref headerData, 0, headerData.Length) > 0)
{
//wopEncryption.Decrypt(header, 0, HEADER_SIZE);
stream.NetworkPayload.Header = new PacketHeader(headerData, 0, this);
if (!DPI.Inspect(stream.NetworkPayload.Header))
{
Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
return;
}
this.stream.ReceiveState = ReceiveType.Payload;
}
}
else
{
DataAvailable = false;
}
break;
}
case ReceiveType.Payload:
{
if (stream.CanRead(stream.NetworkPayload.Header.PacketSize))
{
int receivedSize = stream.NetworkPayload.Header.PacketSize;
uint packetSize = (uint)stream.NetworkPayload.Header.PacketSize;
byte[] payload = stream.Buffer;
uint offset = (uint)stream.Position;
PacketHeader header = stream.NetworkPayload.Header;
IPlugin plugin = null;
uint GenHash = 0;
if (stream.NetworkPayload.Header.PacketID == PacketId.PluginPacket)
{
plugin = pluginSystem.GetPlugin(stream.NetworkPayload.Header.PluginId);
if (plugin == null)
{
throw new Exception("Plugin not found");
}
}
if (Client.Certificate != null)
{
GenHash = stream.NetworkPayload.Header.HashPayload(payload, (int)offset, (int)packetSize, Client.Certificate.Checksum);
if (stream.NetworkPayload.Header.Hash != GenHash)
{
Client.Disconnect(DisconnectReason.DataModificationDetected);
return;
}
}
//peer code
if (stream.NetworkPayload.Header.PeerId != 0 && stream.NetworkPayload.Header.PacketID == PacketId.RootSocket_Payload)
{
if (stream.NetworkPayload.Header.PeerId == Client.VirtualIpInt && !Client.ServerSided)
{
//we arrived at the target peer !
IPeerMessage PeerMsg = null;
try
{
PeerMsg = (IPeerMessage)messageHandler.HandleMessage(new PayloadReader(payload)
{
Offset = (int)offset
}, stream.NetworkPayload.Header.MessageId);
if (PeerMsg != null)
{
PeerMsg.RawSize = stream.NetworkPayload.Header.PacketSize;
PeerMsg.DecompressedRawSize = payload.Length;
}
}
catch (Exception ex)
{
Client.onException(ex, ErrorType.Core);
return;
}
lock (Client.PeerConnections)
{
RootPeer peer = null;
if (Client.PeerConnections.TryGetValue(PeerMsg.ConnectionId, out peer))
{
/*try
* {
* if (!peer.DPI.Inspect(stream.NetworkPayload.Header, PeerMsg))
* {
* Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
* return;
* }
* }
* catch { }*/
PeerMsg.Peer = peer;
RootSocketQueue.Enqueue(PeerMsg);
}
}
}
else if (Client.ServerSided)
{
SSPClient TargetClient = null;
lock (Client.PeerConnections)
{
for (int i = 0; i < Client.PeerConnections.Count; i++)
{
RootPeer rootPeer = Client.PeerConnections.Values[i];
if (rootPeer.FromClient != null && rootPeer.FromClient.VirtualIpInt == stream.NetworkPayload.Header.PeerId)
{
TargetClient = rootPeer.FromClient;
break;
}
if (rootPeer.ToClient != null && rootPeer.ToClient.VirtualIpInt == stream.NetworkPayload.Header.PeerId)
{
TargetClient = rootPeer.ToClient;
break;
}
}
}
if (TargetClient != null)
{
//no protection is being applied to the payload
//the protection should already have been applied
//when the client sended this data to the server
NetworkPayloadWriter pw = new NetworkPayloadWriter(this);
pw.WriteBytes(payload, (int)offset, receivedSize);
TargetClient.Connection.SendPayload(pw, stream.NetworkPayload.Header.MessageId,
PacketId.RootSocket_Payload, false, null, null,
stream.NetworkPayload.Header.PeerId);
}
}
else
{
//strange...
}
this.stream.ReceiveState = ReceiveType.Header;
stream.Position += receivedSize;
payload = null;
break;
}
//decrypt, decompress, de-cache the data we received
if (plugin != null && plugin.UseOwnProtection)
{
payload = plugin.protection.RemoveProtection(payload, ref offset, ref packetSize, ref stream.NetworkPayload.Header);
}
else
{
payload = protection.RemoveProtection(payload, ref offset, ref packetSize, ref stream.NetworkPayload.Header);
}
/*
* if (stream.NetworkPayload.isCached)
* {
* payload = ReceiveCache.DeCache(payload, offset, packetSize);
* offset = 0;
* packetSize = payload.Length;
* }*/
IMessage message = null;
try
{
message = messageHandler.HandleMessage(new PayloadReader(payload)
{
Offset = (int)offset
}, stream.NetworkPayload.Header.MessageId);
if (message != null)
{
message.RawSize = stream.NetworkPayload.Header.PacketSize;
message.DecompressedRawSize = payload.Length;
}
}
catch (Exception ex)
{
Client.onException(ex, ErrorType.Core);
return;
}
if (!Client.DPI.Inspect(null, message))
{
Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
return;
}
/*if(ProcessSpeed == ReceivePerformance.Unsafe)
* {
* if(!MovedPayload && plugin != null && (plugin.UseOwnSystem))
* {
* //payload is not moved from memory and plugin is using his own system
* //We'll just copy the memory...
* payload = new byte[packetSize];
* fixed (byte* dataPtr = payload, streamPtr = stream.Buffer)
* {
* NativeMethods.memcpy(dataPtr, streamPtr, (uint)packetSize);
* }
* }
* }*/
switch (stream.NetworkPayload.Header.PacketID)
{
case PacketId.PacketQueue:
{
PacketTaskQueue.Enqueue(message);
break;
}
case PacketId.ChannelPayload:
{
ChannelPayloadQueue.Enqueue(new ChannelRecvInfo(message, stream.NetworkPayload.Header.ChannelId));
break;
}
case PacketId.CloseChannel:
{
CloseChannelQueue.Enqueue(message);
break;
}
case PacketId.Disconnected:
{
DisconnectedQueue.Enqueue(message);
break;
}
case PacketId.OpenChannel:
{
OpenChannelQueue.Enqueue(message);
break;
}
case PacketId.OpenChannelResponse:
case PacketId.LiteCodeResponse:
case PacketId.KeepAlive:
{
ResponseQueue.Enqueue(message);
break;
}
case PacketId.Payload:
{
PayloadQueue.Enqueue(message);
break;
}
case PacketId.PluginPacket:
{
PluginDataQueue.Enqueue(new PluginRecvInfo(plugin, message, payload));
break;
}
case PacketId.StreamMessages:
{
StreamQueue.Enqueue(message);
break;
}
case PacketId.LiteCode:
{
LiteCodeQueue.Enqueue(message);
break;
}
case PacketId.LiteCode_Delegates:
{
LiteCodeDelegateQueue.Enqueue(message);
break;
}
case PacketId.RequestMessages:
{
RequestQueue.Enqueue(message);
break;
}
}
this.stream.ReceiveState = ReceiveType.Header;
stream.Position += receivedSize;
payload = null;
}
else
{
DataAvailable = false;
}
break;
}
}
}
}
}
/// <summary>
/// This server needs to verify itself and send back a Verfication object.
/// </summary>
/// <param id="state">The server state object.</param>
private static void verifyResponse(ServerState state)
{
Transfers.Verification verification = new Transfers.Verification(NodeID, ClusterManager.HostName, DPI.GetDPI(), Memory.GetTotalSize(), CPU.GetCount(), Executor.RunningJobs(), DomainManager.GetAllDomainKeys(), DomainManager.GetAllAssemblyNames());
SerializationEngine serializer = new SerializationEngine();
state.Write(MessageType.VERIFICATION_RESPONSE, serializer.Serialize(verification).ToArray());
}
