private IEnumerator SendDataTCP(string data)
{
bool shouldRetry = false;
do
{
try
{
_tcpSender.Send(CompressDataWithGzip ? GzipCompression.Compress(data) : data);
shouldRetry = false;
}
catch (Exception e)
{
shouldRetry = true;
}
if (shouldRetry)
{
Debug.LogError("Unable to send TCP data, waiting");
yield return(new WaitForSeconds(WaitNSecondsBetweenTCPSendingFailures));
}
} while (shouldRetry);
yield break;
}
public List <Message> GetDecryptedMessagesWithPrivateKey(string token, string privateKey)
{
var db = new CryptAByteContext();
var request = db.Keys.Include("Messages").SingleOrDefault(key => key.KeyToken == token);
var crypto = new AsymmetricCryptoProvider();
if (!request.IsReleased)
{
throw new ArgumentOutOfRangeException("Request is not released");
}
var plaintextMessages = new List <Message>();
if (request.Messages != null)
{
request.Messages.ToList().ForEach(retrievedMessage =>
{
string messageDecryptionKey;
var decryptedMessage = crypto.DecryptMessageWithKey(privateKey, retrievedMessage.MessageData,
retrievedMessage.EncryptionKey,
retrievedMessage.MessageHash, out messageDecryptionKey);
retrievedMessage.MessageData = decryptedMessage;
retrievedMessage.EncryptionKey = messageDecryptionKey;
if (!retrievedMessage.IsFile)
{
retrievedMessage.MessageData =
GzipCompression.Decompress(retrievedMessage.MessageData);
}
else
{
// this is a zip file
}
plaintextMessages.Add(retrievedMessage);
});
if (request.DeleteMessagesAfterReading || request.DeleteKeyAfterReading)
{
if (request.DeleteMessagesAfterReading || request.DeleteKeyAfterReading)
{
request.Messages.ToList().ForEach(message => db.Messages.Remove(message));
}
if (request.DeleteKeyAfterReading)
{
db.Keys.Remove(request);
}
db.SaveChanges();
}
}
return(plaintextMessages);
}
public int StoreMessage(SelfDestructingMessage selfDestructingMessage, string passphrase, string attachmentName = null,
byte[] attachmentData = null)
{
if (selfDestructingMessage == null)
{
throw new ArgumentOutOfRangeException("selfDestructingMessage required");
}
selfDestructingMessage.Message = GzipCompression.Compress(selfDestructingMessage.Message);
var crypto = new SymmetricCryptoProvider();
selfDestructingMessage.Message = crypto.EncryptWithKey(selfDestructingMessage.Message, passphrase);
var db = new CryptAByteContext();
SelfDestructingMessageAttachment attachment = null;
// save attachment, if it exists
if (attachmentData != null && attachmentData.Length > 0)
{
MemoryStream streamOfOriginalFile = new MemoryStream(1024);
using (ZipFile zip = new ZipFile())
{
zip.AddEntry(attachmentName, attachmentData);
// zip.AddEntry(self, fileData);
zip.Save(streamOfOriginalFile);
}
byte[] zippedFile = RequestRepository.ReadFully(streamOfOriginalFile);
string fileAsString = Convert.ToBase64String(zippedFile);
attachment = new SelfDestructingMessageAttachment {
Attachment = fileAsString
};
attachment.Attachment = crypto.EncryptWithKey(fileAsString, passphrase);
attachment.SentDate = DateTime.Now;
//db.SelfDestructingMessageAttachments.Add(attachment);
}
db.SelfDestructingMessages.Add(selfDestructingMessage);
db.SaveChanges();
if (attachment != null)
{
attachment.MessageId = selfDestructingMessage.MessageId;
db.SelfDestructingMessageAttachments.Add(attachment);
db.ChangeTracker.DetectChanges();
db.SaveChanges();
}
return(selfDestructingMessage.MessageId);
}
public static string GetMessageFromBytes(byte[] message)
{
var bodyTypeLength = message[11] + (message[12] << 8) + (message[13] << 16) + (message[14] << 24);
var messagePosition = 15 + bodyTypeLength;
var messageLength = message[messagePosition] + (message[messagePosition + 1] << 8)
+ (message[messagePosition + 2] << 16) + (message[messagePosition + 3] << 24);
var arrayMessage = new byte[messageLength];
Array.Copy(message, messagePosition + 4, arrayMessage, 0, messageLength);
return(GzipCompression.Unzip(arrayMessage));
}
private void SendDataUDP(string data)
{
if (_udpSender == null)
{
_udpSender = new UDPSender(SendToIp, SendToPort);
_udpSender.Connected += (sender, args) =>
{
Debug.Log("UDP Connected hands data endpoint");
};
}
_udpSender.Send(CompressDataWithGzip ? GzipCompression.Compress(data) : data);
}
private void HandleIncomingData(byte[] data)
{
var stringData = Encoding.ASCII.GetString(data);
var handRelatedData = XmlSerialize.Deserialize <HandRelatedDataContainer>(IsDataGzipCompressed
? GzipCompression.Decompress(stringData)
: stringData);
switch (handRelatedData.HandRelatedData)
{
case HandRelatedData.Hand:
var handData = handRelatedData.HandData;
if (handData.Step == OVRPlugin.Step.Render)
{
if (handData.Hand == OVRPlugin.Hand.HandLeft)
{
_lastLeftHandRenderUpdateDataToProcess = handData;
}
if (handData.Hand == OVRPlugin.Hand.HandRight)
{
_lastRightHandRenderUpdateDataToProcess = handData;
}
}
if (handData.Step == OVRPlugin.Step.Physics)
{
if (handData.Hand == OVRPlugin.Hand.HandLeft)
{
_lastLeftHandPhysicsUpdateDataToProcess = handData;
}
if (handData.Hand == OVRPlugin.Hand.HandRight)
{
_lastRightHandPhysicsUpdateDataToProcess = handData;
}
}
break;
case HandRelatedData.Skeleton:
_skeletonUpdateDataToProcess.Enqueue(handRelatedData.SkeletonData);
break;
case HandRelatedData.Mesh:
_meshUpdateDataToProcess.Enqueue(handRelatedData.MeshData);
break;
case HandRelatedData.Unknown:
default:
throw new ArgumentOutOfRangeException();
}
}
public void AttachMessageToRequest(string token, string plainTextMessage)
{
if (string.IsNullOrWhiteSpace(token))
{
throw new Exception("Token/Identifier is required to attach message!");
}
// compress message:
string compressedMessage = GzipCompression.Compress(plainTextMessage);
AttachDataToKey(token, compressedMessage, false);
NotifyOnMessageReceived(token);
}
public override void LoadTexturePacks()
{
mTexturePackDict.Clear();
var dir = Path.Combine("resources", "packs");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var items = Directory.GetFiles(dir, "*.meta");
for (var i = 0; i < items.Length; i++)
{
var json = GzipCompression.ReadDecompressedString(items[i]);
var obj = JObject.Parse(json);
var frames = (JArray)obj["frames"];
var img = obj["meta"]["image"].ToString();
if (File.Exists(Path.Combine("resources", "packs", img)))
{
var platformText = Core.Graphics.Renderer.LoadTexture(Path.Combine("resources", "packs", img), Path.Combine("resources", "packs", img));
if (platformText != null)
{
foreach (var frame in frames)
{
var filename = frame["filename"].ToString();
var sourceRect = new Rectangle(
int.Parse(frame["frame"]["x"].ToString()), int.Parse(frame["frame"]["y"].ToString()),
int.Parse(frame["frame"]["w"].ToString()), int.Parse(frame["frame"]["h"].ToString())
);
var rotated = bool.Parse(frame["rotated"].ToString());
var sourceSize = new Rectangle(
int.Parse(frame["spriteSourceSize"]["x"].ToString()),
int.Parse(frame["spriteSourceSize"]["y"].ToString()),
int.Parse(frame["spriteSourceSize"]["w"].ToString()),
int.Parse(frame["spriteSourceSize"]["h"].ToString())
);
GameTexturePacks.AddFrame(
new GameTexturePackFrame(filename, sourceRect, rotated, sourceSize, platformText)
);
}
}
}
}
}
public SelfDestructingMessage GetMessage(int messageId, string passphrase)
{
var db = new CryptAByteContext();
SelfDestructingMessage message = db.SelfDestructingMessages.SingleOrDefault(m => m.MessageId == messageId);
//.Include("SelfDestructingMessageAttachment")
if (message == null)
{
throw new ArgumentOutOfRangeException("messageId", "Message not found. Was it already read?");
}
var crypto = new SymmetricCryptoProvider();
try
{
message.Message = crypto.DecryptWithKey(message.Message, passphrase);
var attachment = db.SelfDestructingMessageAttachments.FirstOrDefault(a => a.MessageId == messageId);
if (attachment != null)
{
message.HasAttachment = true;
// todo: get filename here
}
}
catch (Exception)
{
throw new ArgumentOutOfRangeException("passphrase", "server error decrypting message");
}
message.Message = GzipCompression.Decompress(message.Message);
db.SelfDestructingMessages.Remove(message);
db.SaveChanges();
message.SelfDestructingMessageAttachment = new SelfDestructingMessageAttachment
{
// AttachmentName = attachmentName
};
return(message);
}
public override IElectionContext CreateElectionContext(IByteArray compressedContext)
{
GzipCompression compressor = new GzipCompression();
IByteArray decompressedContext = compressor.Decompress(compressedContext);
IDataRehydrator electionContextRehydrator = DataSerializationFactory.CreateRehydrator(decompressedContext);
var version = electionContextRehydrator.RehydrateRewind <ComponentVersion <ElectionContextType> >();
IElectionContext context = null;
if (version.Type == ElectionContextTypes.Instance.Active)
{
if (version == (1, 0))
{
context = new NeuraliumActiveElectionContext();
}
}
if (version.Type == ElectionContextTypes.Instance.Passive)
{
if (version == (1, 0))
{
context = new NeuraliumPassiveElectionContext();
}
}
if (context == null)
{
throw new ApplicationException("Unrecognized election context version.");
}
context.Rehydrate(electionContextRehydrator, this);
decompressedContext.Return();
return(context);
}
public void LoadTexture()
{
if (mTexture != null)
{
return;
}
if (CreateStream != null)
{
using (var stream = CreateStream())
{
Load(stream);
return;
}
}
if (mPackFrame != null)
{
((MonoTexture)mPackFrame.PackTexture)?.LoadTexture();
return;
}
mLoadError = true;
if (string.IsNullOrWhiteSpace(mRealPath))
{
Log.Error("Invalid texture path (empty/null).");
return;
}
var relativePath = FileSystemHelper.RelativePath(Directory.GetCurrentDirectory(), mPath);
if (!File.Exists(mRealPath))
{
Log.Error($"Texture does not exist: {relativePath}");
return;
}
using (var fileStream = File.Open(mRealPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
if (Path.GetExtension(mPath) == ".asset")
{
using (var gzip = GzipCompression.CreateDecompressedFileStream(fileStream))
{
Load(gzip);
}
}
else
{
Load(fileStream);
}
}
catch (Exception exception)
{
Log.Error(
exception,
$"Failed to load texture ({FileSystemHelper.FormatSize( fileStream.Length )}): {relativePath}"
);
ChatboxMsg.AddMessage(
new ChatboxMsg(
Strings.Errors.LoadFile.ToString(Strings.Words.lcase_sprite) + " [" + mName + "]",
new Color(0xBF, 0x0, 0x0), Enums.ChatMessageType.Error
)
);
}
}
}
public void Export(int index)
{
//TODO: Trim Edges
var img = new Bitmap(binWidth, binHeight);
var maxUsedWidth = 0;
var maxUsedHeight = 0;
var g = Graphics.FromImage(img);
var frames = new JArray();
foreach (var tex in textures)
{
var frame = new JObject();
frame.Add("filename", tex.Key.GetPath());
var t = Image.FromFile(tex.Key.GetPath());
var spriteSourceSize = new JObject();
spriteSourceSize["x"] = 0;
spriteSourceSize["y"] = 0;
spriteSourceSize["w"] = t.Width;
spriteSourceSize["h"] = t.Height;
frame["spriteSourceSize"] = spriteSourceSize;
var sourceSize = new JObject();
sourceSize["w"] = t.Width;
sourceSize["h"] = t.Height;
frame["sourceSize"] = sourceSize;
if (tex.Value.Width == t.Height && tex.Value.Height == t.Width && t.Width != t.Height)
{
//Rotated
t.RotateFlip(RotateFlipType.Rotate90FlipNone);
frame["rotated"] = true;
}
else
{
frame["rotated"] = false;
}
g.DrawImage(
t, new RectangleF(tex.Value.X, tex.Value.Y, tex.Value.Width, tex.Value.Height),
new RectangleF(0, 0, t.Width, t.Height), GraphicsUnit.Pixel
);
var frameRect = new JObject();
frameRect["x"] = tex.Value.X;
frameRect["y"] = tex.Value.Y;
frameRect["w"] = tex.Value.Width;
frameRect["h"] = tex.Value.Height;
frame["frame"] = frameRect;
if (tex.Value.Right > maxUsedWidth)
{
maxUsedWidth = tex.Value.Right;
}
if (tex.Value.Bottom > maxUsedHeight)
{
maxUsedHeight = tex.Value.Bottom;
}
t.Dispose();
frames.Add(frame);
}
g.Dispose();
if (maxUsedWidth > 0 && maxUsedHeight > 0)
{
var croppedImg = new Bitmap(maxUsedWidth, maxUsedHeight);
var g1 = Graphics.FromImage(croppedImg);
g1.DrawImage(
img, new RectangleF(0, 0, maxUsedWidth, maxUsedHeight),
new RectangleF(0, 0, maxUsedWidth, maxUsedHeight), GraphicsUnit.Pixel
);
g1.Dispose();
var size = new JObject();
size["w"] = croppedImg.Width;
size["h"] = croppedImg.Height;
using (var stream = GzipCompression.CreateCompressedFileStream(Path.Combine("resources", "packs", "graphics" + index + ".asset")))
{
croppedImg.Save(stream, ImageFormat.Png);
}
croppedImg.Dispose();
//Create Metadata
var jobj = new JObject();
jobj.Add(new JProperty("frames", frames));
var meta = new JObject();
meta["image"] = "graphics" + index + ".asset";
meta["size"] = size;
jobj.Add(new JProperty("meta", meta));
//Save Metadata
GzipCompression.WriteCompressedString(Path.Combine("resources", "packs", "graphics" + index + ".meta"), jobj.ToString());
}
img.Dispose();
}
public static byte[] ToBytes(MessageBus messageBus)
{
var serializedMessage = Serializer.Serialize(messageBus);
var bytesMessage = GzipCompression.Zip(serializedMessage);
var bytesBodyType = Encoding.UTF8.GetBytes(messageBus.Header.BodyType);
CallerContext callerContext = null;
if (messageBus.Header.CallStack.Count > 0)
{
callerContext = messageBus.Header.CallStack.Peek();
}
byte[] idBytes = new byte[0];
byte[] typeBytes = new byte[0];
int bufferLength = 0;
if (callerContext != null)
{
idBytes = Encoding.UTF8.GetBytes(callerContext.Identification.Id);
typeBytes = Encoding.UTF8.GetBytes(callerContext.Identification.Type);
bufferLength = 15 + bytesBodyType.Length + 4 + bytesMessage.Length + 4 + idBytes.Length + 4 +
typeBytes.Length;
}
else
{
bufferLength = 15 + bytesBodyType.Length + 4 + bytesMessage.Length + 4;
}
var bytes = new byte[bufferLength];
bytes[0] = (byte)messageBus.Header.Type;
bytes[1] = (byte)messageBus.Header.Priority;
var ticks = messageBus.Header.CreatedAt.Ticks;
bytes[3] = (byte)(ticks);
bytes[4] = (byte)(ticks >> 8);
bytes[5] = (byte)(ticks >> 16);
bytes[6] = (byte)(ticks >> 24);
bytes[7] = (byte)(ticks >> 32);
bytes[8] = (byte)(ticks >> 40);
bytes[9] = (byte)(ticks >> 48);
bytes[10] = (byte)(ticks >> 56);
bytes[11] = (byte)(bytesBodyType.Length);
bytes[12] = (byte)(bytesBodyType.Length >> 8);
bytes[13] = (byte)(bytesBodyType.Length >> 16);
bytes[14] = (byte)(bytesBodyType.Length >> 24);
Array.Copy(bytesBodyType, 0, bytes, 15, bytesBodyType.Length);
var messagePosition = 15 + bytesBodyType.Length;
bytes[messagePosition] = (byte)(bytesMessage.Length);
bytes[messagePosition + 1] = (byte)(bytesMessage.Length >> 8);
bytes[messagePosition + 2] = (byte)(bytesMessage.Length >> 16);
bytes[messagePosition + 3] = (byte)(bytesMessage.Length >> 24);
Array.Copy(bytesMessage, 0, bytes, messagePosition + 4, bytesMessage.Length);
var idPosition = messagePosition + 4 + bytesMessage.Length;
bytes[idPosition] = (byte)(idBytes.Length);
bytes[idPosition + 1] = (byte)(idBytes.Length >> 8);
bytes[idPosition + 2] = (byte)(idBytes.Length >> 16);
bytes[idPosition + 3] = (byte)(idBytes.Length >> 24);
if (callerContext != null)
{
Array.Copy(idBytes, 0, bytes, idPosition + 4, idBytes.Length);
var typePosition = idPosition + 4 + idBytes.Length;
bytes[typePosition] = (byte)(typeBytes.Length);
bytes[typePosition + 1] = (byte)(typeBytes.Length >> 8);
bytes[typePosition + 2] = (byte)(typeBytes.Length >> 16);
bytes[typePosition + 3] = (byte)(typeBytes.Length >> 24);
Array.Copy(typeBytes, 0, bytes, typePosition + 4, typeBytes.Length);
}
return(bytes);
}
