esiur/esiur-dotnet
2
0
Fork 0
mirror of https://github.com/esiur/esiur-dotnet.git synced 2026-04-03 20:08:21 +00:00
Code Issues Projects Releases Wiki Activity

WIP

Browse Source
This commit is contained in:
ahmed
2026-04-02 19:42:54 +03:00
parent 4fae21deaf
commit 74830eea0c
82 changed files with 2501 additions and 3008 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Esiur.Examples.StandaloneWebServerDemo/Program.cs
View File

@@ -1,6 +1,7 @@
using Esiur.Examples.StandaloneWebServerDemo; using Esiur.Examples.StandaloneWebServerDemo;
using Esiur.Net.HTTP; using Esiur.Net.Http;
using Esiur.Net.Packets.Http;
using Esiur.Protocol; using Esiur.Protocol;
using Esiur.Resource; using Esiur.Resource;
using Esiur.Stores; using Esiur.Stores;
@@ -22,10 +23,10 @@ internal class Program
// Add your object to the store // Add your object to the store
var service = await wh.Put("sys/demo", new Demo()); var service = await wh.Put("sys/demo", new Demo());
var http = await wh.Put<HTTPServer>("sys/http", new HTTPServer() { Port = 8888 }); var http = await wh.Put<HttpServer>("sys/http", new HttpServer() { Port = 8888 });
http.MapGet("{url}", (string url, HTTPConnection sender) => http.MapGet("{url}", (string url, HttpConnection sender) =>
{ {
var fn = "Web/" + (sender.Request.Filename == "/" ? "/index.html" : sender.Request.Filename); var fn = "Web/" + (sender.Request.Filename == "/" ? "/index.html" : sender.Request.Filename);
@@ -42,7 +43,7 @@ internal class Program
} }
else else
{ {
sender.Response.Number = Esiur.Net.Packets.HTTP.HTTPResponseCode.NotFound; sender.Response.Number = HttpResponseCode.NotFound;
sender.Send("`" + fn + "` Not Found"); sender.Send("`" + fn + "` Not Found");
sender.Close(); sender.Close();
} }

2
Esiur/Data/BinaryList.cs
View File

@@ -64,7 +64,7 @@ public class BinaryList
} }
public BinaryList AddUUID(UUID value) public BinaryList AddUUID(Uuid value)
{ {
list.AddRange(value.Data); list.AddRange(value.Data);
return this; return this;

54
Esiur/Data/Codec.cs
View File

@@ -41,8 +41,8 @@ public static class Codec
//delegate AsyncReply AsyncParser(byte[] data, uint offset, uint length, EpConnection connection, uint[] requestSequence); //delegate AsyncReply AsyncParser(byte[] data, uint offset, uint length, EpConnection connection, uint[] requestSequence);
delegate object AsyncParser(ParsedTDU tdu, EpConnection connection, uint[] requestSequence); delegate object AsyncParser(ParsedTdu tdu, EpConnection connection, uint[] requestSequence);
delegate object SyncParser(ParsedTDU tdu, Warehouse warehouse); delegate object SyncParser(ParsedTdu tdu, Warehouse warehouse);
static AsyncParser[][] FixedAsyncParsers = new AsyncParser[][] static AsyncParser[][] FixedAsyncParsers = new AsyncParser[][]
{ {
@@ -195,20 +195,20 @@ public static class Codec
public static (uint, object) ParseAsync(byte[] data, uint offset, EpConnection connection, uint[] requestSequence) public static (uint, object) ParseAsync(byte[] data, uint offset, EpConnection connection, uint[] requestSequence)
{ {
var tdu = ParsedTDU.Parse(data, offset, (uint)data.Length); var tdu = ParsedTdu.Parse(data, offset, (uint)data.Length);
if (tdu.Class == TDUClass.Invalid) if (tdu.Class == TduClass.Invalid)
throw new NullReferenceException("DataType can't be parsed."); throw new NullReferenceException("DataType can't be parsed.");
if (tdu.Class == TDUClass.Fixed) if (tdu.Class == TduClass.Fixed)
{ {
return ((uint)tdu.TotalLength, FixedAsyncParsers[tdu.Exponent][tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, FixedAsyncParsers[tdu.Exponent][tdu.Index](tdu, connection, requestSequence));
} }
else if (tdu.Class == TDUClass.Dynamic) else if (tdu.Class == TduClass.Dynamic)
{ {
return ((uint)tdu.TotalLength, DynamicAsyncParsers[tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, DynamicAsyncParsers[tdu.Index](tdu, connection, requestSequence));
} }
else if (tdu.Class == TDUClass.Typed) else if (tdu.Class == TduClass.Typed)
{ {
return ((uint)tdu.TotalLength, TypedAsyncParsers[tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, TypedAsyncParsers[tdu.Index](tdu, connection, requestSequence));
} }
@@ -219,20 +219,20 @@ public static class Codec
} }
} }
public static (uint, object) ParseAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static (uint, object) ParseAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
if (tdu.Class == TDUClass.Invalid) if (tdu.Class == TduClass.Invalid)
throw new NullReferenceException("DataType can't be parsed."); throw new NullReferenceException("DataType can't be parsed.");
if (tdu.Class == TDUClass.Fixed) if (tdu.Class == TduClass.Fixed)
{ {
return ((uint)tdu.TotalLength, FixedAsyncParsers[tdu.Exponent][tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, FixedAsyncParsers[tdu.Exponent][tdu.Index](tdu, connection, requestSequence));
} }
else if (tdu.Class == TDUClass.Dynamic) else if (tdu.Class == TduClass.Dynamic)
{ {
return ((uint)tdu.TotalLength, DynamicAsyncParsers[tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, DynamicAsyncParsers[tdu.Index](tdu, connection, requestSequence));
} }
else if (tdu.Class == TDUClass.Typed) else if (tdu.Class == TduClass.Typed)
{ {
return ((uint)tdu.TotalLength, TypedAsyncParsers[tdu.Index](tdu, connection, requestSequence)); return ((uint)tdu.TotalLength, TypedAsyncParsers[tdu.Index](tdu, connection, requestSequence));
} }
@@ -243,17 +243,17 @@ public static class Codec
} }
} }
public static (uint, object) ParseSync(ParsedTDU tdu, Warehouse warehouse) public static (uint, object) ParseSync(ParsedTdu tdu, Warehouse warehouse)
{ {
if (tdu.Class == TDUClass.Fixed) if (tdu.Class == TduClass.Fixed)
{ {
return ((uint)tdu.TotalLength, FixedParsers[tdu.Exponent][tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, FixedParsers[tdu.Exponent][tdu.Index](tdu, warehouse));
} }
else if (tdu.Class == TDUClass.Dynamic) else if (tdu.Class == TduClass.Dynamic)
{ {
return ((uint)tdu.TotalLength, DynamicParsers[tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, DynamicParsers[tdu.Index](tdu, warehouse));
} }
else if (tdu.Class == TDUClass.Typed) else if (tdu.Class == TduClass.Typed)
{ {
return ((uint)tdu.TotalLength, TypedParsers[tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, TypedParsers[tdu.Index](tdu, warehouse));
} }
@@ -266,21 +266,21 @@ public static class Codec
public static (uint, object) ParseSync(byte[] data, uint offset, Warehouse warehouse) public static (uint, object) ParseSync(byte[] data, uint offset, Warehouse warehouse)
{ {
var tdu = ParsedTDU.Parse(data, offset, (uint)data.Length); var tdu = ParsedTdu.Parse(data, offset, (uint)data.Length);
if (tdu.Class == TDUClass.Invalid) if (tdu.Class == TduClass.Invalid)
throw new NullReferenceException("DataType can't be parsed."); throw new NullReferenceException("DataType can't be parsed.");
if (tdu.Class == TDUClass.Fixed) if (tdu.Class == TduClass.Fixed)
{ {
return ((uint)tdu.TotalLength, FixedParsers[tdu.Exponent][tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, FixedParsers[tdu.Exponent][tdu.Index](tdu, warehouse));
} }
else if (tdu.Class == TDUClass.Dynamic) else if (tdu.Class == TduClass.Dynamic)
{ {
return ((uint)tdu.TotalLength, DynamicParsers[tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, DynamicParsers[tdu.Index](tdu, warehouse));
} }
else if (tdu.Class == TDUClass.Typed) else if (tdu.Class == TduClass.Typed)
{ {
return ((uint)tdu.TotalLength, TypedParsers[tdu.Index](tdu, warehouse)); return ((uint)tdu.TotalLength, TypedParsers[tdu.Index](tdu, warehouse));
} }
@@ -307,7 +307,7 @@ public static class Codec
return false; return false;
} }
public delegate TDU Composer(object value, Warehouse warehouse, EpConnection connection); public delegate Tdu Composer(object value, Warehouse warehouse, EpConnection connection);
public static Dictionary<Type, Composer> Composers = new Dictionary<Type, Composer>() public static Dictionary<Type, Composer> Composers = new Dictionary<Type, Composer>()
{ {
@@ -347,7 +347,7 @@ public static class Codec
//[typeof(List<byte?>)] = DataSerializer.RawDataComposerFromList, //[typeof(List<byte?>)] = DataSerializer.RawDataComposerFromList,
[typeof(string)] = DataSerializer.StringComposer, [typeof(string)] = DataSerializer.StringComposer,
[typeof(ResourceLink)] = DataSerializer.ResourceLinkComposer, [typeof(ResourceLink)] = DataSerializer.ResourceLinkComposer,
[typeof(UUID)] = DataSerializer.UUIDComposer, [typeof(Uuid)] = DataSerializer.UUIDComposer,
// Special // Special
[typeof(object[])] = DataSerializer.ListComposer, [typeof(object[])] = DataSerializer.ListComposer,
[typeof(List<object>)] = DataSerializer.ListComposer, [typeof(List<object>)] = DataSerializer.ListComposer,
@@ -381,11 +381,11 @@ public static class Codec
}; };
internal static TDU internal static Tdu
ComposeInternal(object valueOrSource, Warehouse warehouse, EpConnection connection) ComposeInternal(object valueOrSource, Warehouse warehouse, EpConnection connection)
{ {
if (valueOrSource == null) if (valueOrSource == null)
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
var type = valueOrSource.GetType(); var type = valueOrSource.GetType();
@@ -412,7 +412,7 @@ public static class Codec
valueOrSource = ((IUserType)valueOrSource).Get(); valueOrSource = ((IUserType)valueOrSource).Get();
if (valueOrSource == null) if (valueOrSource == null)
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
type = valueOrSource.GetType(); type = valueOrSource.GetType();
@@ -488,7 +488,7 @@ public static class Codec
} }
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
} }

4
Esiur/Data/DataConverter.cs
View File

@@ -813,9 +813,9 @@ public static class DC // Data Converter
return ar.ToArray(); return ar.ToArray();
} }
public static UUID GetUUID(this byte[] data, uint offset) public static Uuid GetUUID(this byte[] data, uint offset)
{ {
return new UUID(data, offset); return new Uuid(data, offset);
} }
//public static Guid GetGuid(this byte[] data, uint offset) //public static Guid GetGuid(this byte[] data, uint offset)

322
Esiur/Data/DataDeserializer.cs
View File

@@ -17,246 +17,246 @@ namespace Esiur.Data;
public static class DataDeserializer public static class DataDeserializer
{ {
public static object NullParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object NullParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return null; return null;
} }
public static object NullParser(ParsedTDU tdu, Warehouse warehouse) public static object NullParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return null; return null;
} }
public static object BooleanTrueParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object BooleanTrueParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return true; return true;
} }
public static object BooleanTrueParser(ParsedTDU tdu, Warehouse warehouse) public static object BooleanTrueParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return true; return true;
} }
public static object BooleanFalseParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object BooleanFalseParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return false; return false;
} }
public static object BooleanFalseParser(ParsedTDU tdu, Warehouse warehouse) public static object BooleanFalseParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return false; return false;
} }
public static object NotModifiedParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object NotModifiedParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return NotModified.Default; return NotModified.Default;
} }
public static object NotModifiedParser(ParsedTDU tdu, Warehouse warehouse) public static object NotModifiedParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return NotModified.Default; return NotModified.Default;
} }
public static object UInt8ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object UInt8ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return tdu.Data[tdu.Offset]; return tdu.Data[tdu.Offset];
} }
public static object UInt8Parser(ParsedTDU tdu, Warehouse warehouse) public static object UInt8Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
return tdu.Data[tdu.Offset]; return tdu.Data[tdu.Offset];
} }
public static object Int8ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object Int8ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return (sbyte)tdu.Data[tdu.Offset]; return (sbyte)tdu.Data[tdu.Offset];
} }
public static object Int8Parser(ParsedTDU tdu, Warehouse warehouse) public static object Int8Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
return (sbyte)tdu.Data[tdu.Offset]; return (sbyte)tdu.Data[tdu.Offset];
} }
public static unsafe object Char16ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Char16ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(char*)ptr; return *(char*)ptr;
} }
public static unsafe object Char16Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Char16Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(char*)ptr; return *(char*)ptr;
} }
public static object Char8ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object Char8ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return (char)tdu.Data[tdu.Offset]; return (char)tdu.Data[tdu.Offset];
} }
public static object Char8Parser(ParsedTDU tdu, Warehouse warehouse) public static object Char8Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
return (char)tdu.Data[tdu.Offset]; return (char)tdu.Data[tdu.Offset];
} }
public static unsafe object Int16ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Int16ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(short*)ptr; return *(short*)ptr;
} }
public static unsafe object Int16Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Int16Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(short*)ptr; return *(short*)ptr;
} }
public static unsafe object UInt16ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object UInt16ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(ushort*)ptr; return *(ushort*)ptr;
} }
public static unsafe object UInt16Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object UInt16Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(ushort*)ptr; return *(ushort*)ptr;
} }
public static unsafe object Int32ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Int32ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(int*)ptr; return *(int*)ptr;
} }
public static unsafe object Int32Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Int32Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(int*)ptr; return *(int*)ptr;
} }
public static unsafe object UInt32ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object UInt32ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(uint*)ptr; return *(uint*)ptr;
} }
public static unsafe object UInt32Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object UInt32Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(uint*)ptr; return *(uint*)ptr;
} }
public static unsafe object Float32ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Float32ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(float*)ptr; return *(float*)ptr;
} }
public static unsafe object Float32Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Float32Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(float*)ptr; return *(float*)ptr;
} }
public static unsafe object Float64ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Float64ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(double*)ptr; return *(double*)ptr;
} }
public static unsafe object Float64Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Float64Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(double*)ptr; return *(double*)ptr;
} }
public static unsafe object Decimal128ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Decimal128ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(decimal*)ptr; return *(decimal*)ptr;
} }
public static unsafe object Decimal128Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Decimal128Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(decimal*)ptr; return *(decimal*)ptr;
} }
public static unsafe object UUIDParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object UUIDParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return new UUID(tdu.Data, tdu.Offset); return new Uuid(tdu.Data, tdu.Offset);
} }
public static unsafe object UUIDParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object UUIDParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return new UUID(tdu.Data, tdu.Offset); return new Uuid(tdu.Data, tdu.Offset);
} }
public static unsafe object Int128ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Int128ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr1 = &tdu.Data[tdu.Offset]) fixed (byte* ptr1 = &tdu.Data[tdu.Offset])
fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8]) fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8])
return new Int128(*(ulong*)ptr1, *(ulong*)ptr2); return new Int128(*(ulong*)ptr1, *(ulong*)ptr2);
} }
public static unsafe object Int128Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Int128Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr1 = &tdu.Data[tdu.Offset]) fixed (byte* ptr1 = &tdu.Data[tdu.Offset])
fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8]) fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8])
return new Int128(*(ulong*)ptr1, *(ulong*)ptr2); return new Int128(*(ulong*)ptr1, *(ulong*)ptr2);
} }
public static unsafe object UInt128ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object UInt128ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr1 = &tdu.Data[tdu.Offset]) fixed (byte* ptr1 = &tdu.Data[tdu.Offset])
fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8]) fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8])
return new UInt128(*(ulong*)ptr1, *(ulong*)ptr2); return new UInt128(*(ulong*)ptr1, *(ulong*)ptr2);
} }
public static unsafe object UInt128Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object UInt128Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr1 = &tdu.Data[tdu.Offset]) fixed (byte* ptr1 = &tdu.Data[tdu.Offset])
fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8]) fixed (byte* ptr2 = &tdu.Data[tdu.Offset + 8])
return new UInt128(*(ulong*)ptr1, *(ulong*)ptr2); return new UInt128(*(ulong*)ptr1, *(ulong*)ptr2);
} }
public static unsafe object Int64ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object Int64ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(long*)ptr; return *(long*)ptr;
} }
public static unsafe object Int64Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object Int64Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(long*)ptr; return *(long*)ptr;
} }
public static unsafe object UInt64ParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object UInt64ParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(ulong*)ptr; return *(ulong*)ptr;
} }
public static unsafe object UInt64Parser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object UInt64Parser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return *(ulong*)ptr; return *(ulong*)ptr;
} }
public static unsafe object DateTimeParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object DateTimeParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new DateTime(*(long*)ptr, DateTimeKind.Utc); return new DateTime(*(long*)ptr, DateTimeKind.Utc);
} }
public static unsafe object DateTimeParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object DateTimeParser(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new DateTime(*(long*)ptr, DateTimeKind.Utc); return new DateTime(*(long*)ptr, DateTimeKind.Utc);
@@ -264,7 +264,7 @@ public static class DataDeserializer
} }
public static object ResourceLinkParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static object ResourceLinkParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var link = tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength); var link = tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength);
if (connection == null) if (connection == null)
@@ -277,13 +277,13 @@ public static class DataDeserializer
} }
} }
public static object ResourceLinkParser(ParsedTDU tdu, Warehouse warehouse) public static object ResourceLinkParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var link = tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength); var link = tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength);
return new ResourceLink(link); return new ResourceLink(link);
} }
public static unsafe object ResourceParser8Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object ResourceParser8Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
if (connection == null) if (connection == null)
return new ResourceId(false, tdu.Data[tdu.Offset]); return new ResourceId(false, tdu.Data[tdu.Offset]);
@@ -291,12 +291,12 @@ public static class DataDeserializer
return connection.Fetch(tdu.Data[tdu.Offset], requestSequence); return connection.Fetch(tdu.Data[tdu.Offset], requestSequence);
} }
public static unsafe object ResourceParser8(ParsedTDU tdu, Warehouse warehouse) public static unsafe object ResourceParser8(ParsedTdu tdu, Warehouse warehouse)
{ {
return new ResourceId(false, tdu.Data[tdu.Offset]); return new ResourceId(false, tdu.Data[tdu.Offset]);
} }
public static unsafe object LocalResourceParser8Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object LocalResourceParser8Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
if (connection == null) if (connection == null)
return new ResourceId(true, tdu.Data[tdu.Offset]); return new ResourceId(true, tdu.Data[tdu.Offset]);
@@ -304,12 +304,12 @@ public static class DataDeserializer
return connection.Instance.Warehouse.GetById(tdu.Data[tdu.Offset]); return connection.Instance.Warehouse.GetById(tdu.Data[tdu.Offset]);
} }
public static unsafe object LocalResourceParser8(ParsedTDU tdu, Warehouse warehouse) public static unsafe object LocalResourceParser8(ParsedTdu tdu, Warehouse warehouse)
{ {
return new ResourceId(true, tdu.Data[tdu.Offset]); return new ResourceId(true, tdu.Data[tdu.Offset]);
} }
public static unsafe object ResourceParser16Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object ResourceParser16Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
if (connection == null) if (connection == null)
@@ -318,14 +318,14 @@ public static class DataDeserializer
return connection.Fetch(*(ushort*)ptr, requestSequence); return connection.Fetch(*(ushort*)ptr, requestSequence);
} }
public static unsafe object ResourceParser16(ParsedTDU tdu, Warehouse warehouse) public static unsafe object ResourceParser16(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new ResourceId(false, *(ushort*)ptr); return new ResourceId(false, *(ushort*)ptr);
} }
public static unsafe object LocalResourceParser16Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object LocalResourceParser16Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
if (connection == null) if (connection == null)
@@ -334,13 +334,13 @@ public static class DataDeserializer
return connection.Instance.Warehouse.GetById(*(ushort*)ptr); return connection.Instance.Warehouse.GetById(*(ushort*)ptr);
} }
public static unsafe object LocalResourceParser16(ParsedTDU tdu, Warehouse warehouse) public static unsafe object LocalResourceParser16(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new ResourceId(true, *(ushort*)ptr); return new ResourceId(true, *(ushort*)ptr);
} }
public static unsafe object ResourceParser32Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object ResourceParser32Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
if (connection == null) if (connection == null)
@@ -349,14 +349,14 @@ public static class DataDeserializer
return connection.Fetch(*(uint*)ptr, requestSequence); return connection.Fetch(*(uint*)ptr, requestSequence);
} }
public static unsafe object ResourceParser32(ParsedTDU tdu, Warehouse warehouse) public static unsafe object ResourceParser32(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new ResourceId(false, *(uint*)ptr); return new ResourceId(false, *(uint*)ptr);
} }
public static unsafe object LocalResourceParser32Async(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object LocalResourceParser32Async(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
if (connection == null) if (connection == null)
@@ -365,35 +365,35 @@ public static class DataDeserializer
return connection.Instance.Warehouse.GetById(*(uint*)ptr); return connection.Instance.Warehouse.GetById(*(uint*)ptr);
} }
public static unsafe object LocalResourceParser32(ParsedTDU tdu, Warehouse warehouse) public static unsafe object LocalResourceParser32(ParsedTdu tdu, Warehouse warehouse)
{ {
fixed (byte* ptr = &tdu.Data[tdu.Offset]) fixed (byte* ptr = &tdu.Data[tdu.Offset])
return new ResourceId(true, *(uint*)ptr); return new ResourceId(true, *(uint*)ptr);
} }
public static unsafe object RawDataParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object RawDataParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return tdu.Data.Clip(tdu.Offset, (uint)tdu.ContentLength); return tdu.Data.Clip(tdu.Offset, (uint)tdu.ContentLength);
} }
public static unsafe object RawDataParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object RawDataParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return tdu.Data.Clip(tdu.Offset, (uint)tdu.ContentLength); return tdu.Data.Clip(tdu.Offset, (uint)tdu.ContentLength);
} }
public static unsafe object StringParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object StringParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
return tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength); return tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength);
} }
public static unsafe object StringParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object StringParser(ParsedTdu tdu, Warehouse warehouse)
{ {
return tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength); return tdu.Data.GetString(tdu.Offset, (uint)tdu.ContentLength);
} }
public static unsafe object RecordParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object RecordParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var typeId = tdu.Metadata.GetUUID(0); var typeId = tdu.Metadata.GetUUID(0);
var typeDef = connection.Instance.Warehouse.GetTypeDefById(typeId, var typeDef = connection.Instance.Warehouse.GetTypeDefById(typeId,
@@ -403,8 +403,8 @@ public static class DataDeserializer
var list = new AsyncBag<object>(); var list = new AsyncBag<object>();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -414,22 +414,22 @@ public static class DataDeserializer
{ {
for (var i = 0; i < typeDef.Properties.Length; i++) for (var i = 0; i < typeDef.Properties.Length; i++)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
current.Metadata = previous.Value.Metadata; current.Metadata = previous.Value.Metadata;
} }
else if (current.Identifier == TDUIdentifier.TypeOfTarget) else if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = typeDef.Properties[i].ValueType.GetMetadata(); var (idf, mt) = typeDef.Properties[i].ValueType.GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -515,7 +515,7 @@ public static class DataDeserializer
} }
public static unsafe object RecordParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object RecordParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var typeId = tdu.Metadata.GetUUID(0); var typeId = tdu.Metadata.GetUUID(0);
var typeDef = warehouse.GetTypeDefById(typeId, TypeDefKind.Record); var typeDef = warehouse.GetTypeDefById(typeId, TypeDefKind.Record);
@@ -529,8 +529,8 @@ public static class DataDeserializer
var list = new List<object>(); var list = new List<object>();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -539,22 +539,22 @@ public static class DataDeserializer
for (var i = 0; i < typeDef.Properties.Length; i++) for (var i = 0; i < typeDef.Properties.Length; i++)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
current.Metadata = previous.Value.Metadata; current.Metadata = previous.Value.Metadata;
} }
else if (current.Identifier == TDUIdentifier.TypeOfTarget) else if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = typeDef.Properties[i].ValueType.GetMetadata(); var (idf, mt) = typeDef.Properties[i].ValueType.GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -605,17 +605,17 @@ public static class DataDeserializer
} }
} }
public static unsafe object ConstantParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe object ConstantParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
public static unsafe object ConstantParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object ConstantParser(ParsedTdu tdu, Warehouse warehouse)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
public static unsafe AsyncReply EnumParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static unsafe AsyncReply EnumParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var typeId = tdu.Metadata.GetUUID(0); var typeId = tdu.Metadata.GetUUID(0);
@@ -643,7 +643,7 @@ public static class DataDeserializer
} }
} }
public static unsafe object EnumParser(ParsedTDU tdu, Warehouse warehouse) public static unsafe object EnumParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var typeId = tdu.Metadata.GetUUID(0); var typeId = tdu.Metadata.GetUUID(0);
@@ -664,7 +664,7 @@ public static class DataDeserializer
} }
public static AsyncReply RecordListParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncReply RecordListParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var rt = new AsyncBag<IRecord>(); var rt = new AsyncBag<IRecord>();
@@ -691,7 +691,7 @@ public static class DataDeserializer
return rt; return rt;
} }
public static object RecordListParser(ParsedTDU tdu, Warehouse warehouse) public static object RecordListParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var rt = new List<IRecord>(); var rt = new List<IRecord>();
@@ -717,7 +717,7 @@ public static class DataDeserializer
return rt.ToArray(); return rt.ToArray();
} }
public static AsyncReply ResourceListParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncReply ResourceListParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var rt = new AsyncBag<IResource>(); var rt = new AsyncBag<IResource>();
@@ -745,7 +745,7 @@ public static class DataDeserializer
} }
public static object ResourceListParser(ParsedTDU tdu, Warehouse warehouse) public static object ResourceListParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var rt = new List<IResource>(); var rt = new List<IResource>();
@@ -771,7 +771,7 @@ public static class DataDeserializer
return rt.ToArray(); return rt.ToArray();
} }
public static AsyncBag<object> ListParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncBag<object> ListParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
//var rt = new AsyncBag<object>(); //var rt = new AsyncBag<object>();
@@ -806,8 +806,8 @@ public static class DataDeserializer
//var list = new List<object>(); //var list = new List<object>();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -815,13 +815,13 @@ public static class DataDeserializer
while (length > 0) while (length > 0)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
@@ -850,12 +850,12 @@ public static class DataDeserializer
} }
public static object ListParser(ParsedTDU tdu, Warehouse warehouse) public static object ListParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var list = new List<object>(); var list = new List<object>();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -863,13 +863,13 @@ public static class DataDeserializer
while (length > 0) while (length > 0)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
@@ -923,25 +923,25 @@ public static class DataDeserializer
} }
public static AsyncReply TypedMapParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncReply TypedMapParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var rt = new AsyncReply(); var rt = new AsyncReply();
// get key type // get key type
var (keyCs, keysTru) = TRU.Parse(tdu.Metadata, 0); var (keyCs, keysTru) = Tru.Parse(tdu.Metadata, 0);
var (valueCs, valuesTru) = TRU.Parse(tdu.Metadata, keyCs); var (valueCs, valuesTru) = Tru.Parse(tdu.Metadata, keyCs);
var map = (IMap)Activator.CreateInstance(typeof(Map<,>).MakeGenericType( var map = (IMap)Activator.CreateInstance(typeof(Map<,>).MakeGenericType(
keysTru.GetRuntimeType(connection.Instance.Warehouse), keysTru.GetRuntimeType(connection.Instance.Warehouse),
valuesTru.GetRuntimeType(connection.Instance.Warehouse))); valuesTru.GetRuntimeType(connection.Instance.Warehouse)));
var keysTdu = ParsedTDU.Parse(tdu.Data, tdu.Offset, var keysTdu = ParsedTdu.Parse(tdu.Data, tdu.Offset,
(uint)(tdu.Offset + tdu.ContentLength)); (uint)(tdu.Offset + tdu.ContentLength));
var valuesTdu = ParsedTDU.Parse(tdu.Data, var valuesTdu = ParsedTdu.Parse(tdu.Data,
(uint)(keysTdu.Offset + keysTdu.ContentLength), (uint)(keysTdu.Offset + keysTdu.ContentLength),
tdu.Ends); tdu.Ends);
@@ -1011,29 +1011,29 @@ public static class DataDeserializer
} }
public static Array TypedArrayParser(ParsedTDU tdu, TRU tru, Warehouse warehouse) public static Array TypedArrayParser(ParsedTdu tdu, Tru tru, Warehouse warehouse)
{ {
switch (tru.Identifier) switch (tru.Identifier)
{ {
case TRUIdentifier.Int32: case TruIdentifier.Int32:
return GroupInt32Codec.Decode(tdu.Data.AsSpan( return GroupInt32Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.Int64: case TruIdentifier.Int64:
return GroupInt64Codec.Decode(tdu.Data.AsSpan( return GroupInt64Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.Int16: case TruIdentifier.Int16:
return GroupInt16Codec.Decode(tdu.Data.AsSpan( return GroupInt16Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.UInt32: case TruIdentifier.UInt32:
return GroupUInt32Codec.Decode(tdu.Data.AsSpan( return GroupUInt32Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.UInt64: case TruIdentifier.UInt64:
return GroupUInt64Codec.Decode(tdu.Data.AsSpan( return GroupUInt64Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.UInt16: case TruIdentifier.UInt16:
return GroupUInt16Codec.Decode(tdu.Data.AsSpan( return GroupUInt16Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength)); (int)tdu.Offset, (int)tdu.ContentLength));
case TRUIdentifier.Enum: case TruIdentifier.Enum:
var enumType = tru.GetRuntimeType(warehouse); var enumType = tru.GetRuntimeType(warehouse);
@@ -1053,8 +1053,8 @@ public static class DataDeserializer
var list = new List<object>(); var list = new List<object>();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -1062,22 +1062,22 @@ public static class DataDeserializer
while (length > 0) while (length > 0)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
current.Metadata = previous.Value.Metadata; current.Metadata = previous.Value.Metadata;
} }
else if (current.Identifier == TDUIdentifier.TypeOfTarget) else if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = tru.GetMetadata(); var (idf, mt) = tru.GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -1107,21 +1107,21 @@ public static class DataDeserializer
} }
public static object TypedMapParser(ParsedTDU tdu, Warehouse warehouse) public static object TypedMapParser(ParsedTdu tdu, Warehouse warehouse)
{ {
// get key type // get key type
var (keyCs, keysTru) = TRU.Parse(tdu.Metadata, 0); var (keyCs, keysTru) = Tru.Parse(tdu.Metadata, 0);
var (valueCs, valuesTru) = TRU.Parse(tdu.Metadata, keyCs); var (valueCs, valuesTru) = Tru.Parse(tdu.Metadata, keyCs);
var map = (IMap)Activator.CreateInstance(typeof(Map<,>).MakeGenericType(keysTru.GetRuntimeType(warehouse), valuesTru.GetRuntimeType(warehouse))); var map = (IMap)Activator.CreateInstance(typeof(Map<,>).MakeGenericType(keysTru.GetRuntimeType(warehouse), valuesTru.GetRuntimeType(warehouse)));
var keysTdu = ParsedTDU.Parse(tdu.Data, tdu.Offset, var keysTdu = ParsedTdu.Parse(tdu.Data, tdu.Offset,
(uint)(tdu.Offset + tdu.ContentLength)); (uint)(tdu.Offset + tdu.ContentLength));
var valuesTdu = ParsedTDU.Parse(tdu.Data, var valuesTdu = ParsedTdu.Parse(tdu.Data,
(uint)(keysTdu.Offset + keysTdu.ContentLength), (uint)(keysTdu.Offset + keysTdu.ContentLength),
tdu.Ends); tdu.Ends);
@@ -1135,20 +1135,20 @@ public static class DataDeserializer
} }
public static AsyncReply TupleParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncReply TupleParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
var rt = new AsyncReply(); var rt = new AsyncReply();
// var tupleSize = tdu.Metadata[0]; // var tupleSize = tdu.Metadata[0];
var trus = new List<TRU>(); var trus = new List<Tru>();
uint mtOffset = 0; uint mtOffset = 0;
while (mtOffset < tdu.Metadata.Length) while (mtOffset < tdu.Metadata.Length)
{ {
var (cs, tru) = TRU.Parse(tdu.Metadata, mtOffset); var (cs, tru) = Tru.Parse(tdu.Metadata, mtOffset);
trus.Add(tru); trus.Add(tru);
mtOffset += cs; mtOffset += cs;
} }
@@ -1156,8 +1156,8 @@ public static class DataDeserializer
var results = new AsyncBag<object>(); var results = new AsyncBag<object>();
var types = trus.Select(x => x.GetRuntimeType(connection.Instance.Warehouse)).ToArray(); var types = trus.Select(x => x.GetRuntimeType(connection.Instance.Warehouse)).ToArray();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -1166,15 +1166,15 @@ public static class DataDeserializer
for (var i = 0; i < trus.Count; i++) for (var i = 0; i < trus.Count; i++)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeOfTarget) if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = trus[i].GetMetadata(); var (idf, mt) = trus[i].GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -1234,16 +1234,16 @@ public static class DataDeserializer
return rt; return rt;
} }
public static object TupleParser(ParsedTDU tdu, Warehouse warehouse) public static object TupleParser(ParsedTdu tdu, Warehouse warehouse)
{ {
var tupleSize = tdu.Metadata[0]; var tupleSize = tdu.Metadata[0];
var trus = new List<TRU>(); var trus = new List<Tru>();
uint mtOffset = 1; uint mtOffset = 1;
for (var i = 0; i < tupleSize; i++) for (var i = 0; i < tupleSize; i++)
{ {
var (cs, tru) = TRU.Parse(tdu.Metadata, mtOffset); var (cs, tru) = Tru.Parse(tdu.Metadata, mtOffset);
trus.Add(tru); trus.Add(tru);
mtOffset += cs; mtOffset += cs;
} }
@@ -1251,8 +1251,8 @@ public static class DataDeserializer
var results = new List<object>(); var results = new List<object>();
var types = trus.Select(x => x.GetRuntimeType(warehouse)).ToArray(); var types = trus.Select(x => x.GetRuntimeType(warehouse)).ToArray();
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -1261,15 +1261,15 @@ public static class DataDeserializer
for (var i = 0; i < tupleSize; i++) for (var i = 0; i < tupleSize; i++)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeOfTarget) if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = trus[i].GetMetadata(); var (idf, mt) = trus[i].GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -1325,30 +1325,30 @@ public static class DataDeserializer
} }
public static AsyncReply TypedArrayParserAsync(ParsedTDU tdu, TRU tru, EpConnection connection, uint[] requestSequence) public static AsyncReply TypedArrayParserAsync(ParsedTdu tdu, Tru tru, EpConnection connection, uint[] requestSequence)
{ {
switch (tru.Identifier) switch (tru.Identifier)
{ {
case TRUIdentifier.Int32: case TruIdentifier.Int32:
return new AsyncReply(GroupInt32Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupInt32Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.Int64: case TruIdentifier.Int64:
return new AsyncReply(GroupInt64Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupInt64Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.Int16: case TruIdentifier.Int16:
return new AsyncReply(GroupInt16Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupInt16Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.UInt32: case TruIdentifier.UInt32:
return new AsyncReply(GroupUInt32Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupUInt32Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.UInt64: case TruIdentifier.UInt64:
return new AsyncReply(GroupUInt64Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupUInt64Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.UInt16: case TruIdentifier.UInt16:
return new AsyncReply(GroupUInt16Codec.Decode(tdu.Data.AsSpan( return new AsyncReply(GroupUInt16Codec.Decode(tdu.Data.AsSpan(
(int)tdu.Offset, (int)tdu.ContentLength))); (int)tdu.Offset, (int)tdu.ContentLength)));
case TRUIdentifier.Enum: case TruIdentifier.Enum:
var enumType = tru.GetRuntimeType(connection.Instance.Warehouse); var enumType = tru.GetRuntimeType(connection.Instance.Warehouse);
var rt = Array.CreateInstance(enumType, (int)tdu.ContentLength); var rt = Array.CreateInstance(enumType, (int)tdu.ContentLength);
@@ -1370,8 +1370,8 @@ public static class DataDeserializer
list.ArrayType = tru.GetRuntimeType(connection.Instance.Warehouse); list.ArrayType = tru.GetRuntimeType(connection.Instance.Warehouse);
ParsedTDU current; ParsedTdu current;
ParsedTDU? previous = null; ParsedTdu? previous = null;
var offset = tdu.Offset; var offset = tdu.Offset;
var length = tdu.ContentLength; var length = tdu.ContentLength;
@@ -1379,22 +1379,22 @@ public static class DataDeserializer
while (length > 0) while (length > 0)
{ {
current = ParsedTDU.Parse(tdu.Data, offset, ends); current = ParsedTdu.Parse(tdu.Data, offset, ends);
if (current.Class == TDUClass.Invalid) if (current.Class == TduClass.Invalid)
throw new Exception("Unknown type."); throw new Exception("Unknown type.");
if (current.Identifier == TDUIdentifier.TypeContinuation) if (current.Identifier == TduIdentifier.TypeContinuation)
{ {
current.Class = previous.Value.Class; current.Class = previous.Value.Class;
current.Identifier = previous.Value.Identifier; current.Identifier = previous.Value.Identifier;
current.Metadata = previous.Value.Metadata; current.Metadata = previous.Value.Metadata;
} }
else if (current.Identifier == TDUIdentifier.TypeOfTarget) else if (current.Identifier == TduIdentifier.TypeOfTarget)
{ {
var (idf, mt) = tru.GetMetadata(); var (idf, mt) = tru.GetMetadata();
current.Class = TDUClass.Typed; current.Class = TduClass.Typed;
current.Identifier = idf; current.Identifier = idf;
current.Metadata = mt; current.Metadata = mt;
current.Index = (int)idf & 0x7; current.Index = (int)idf & 0x7;
@@ -1421,10 +1421,10 @@ public static class DataDeserializer
} }
public static AsyncReply TypedListParserAsync(ParsedTDU tdu, EpConnection connection, uint[] requestSequence) public static AsyncReply TypedListParserAsync(ParsedTdu tdu, EpConnection connection, uint[] requestSequence)
{ {
// get the type // get the type
var (hdrCs, tru) = TRU.Parse(tdu.Metadata, 0); var (hdrCs, tru) = Tru.Parse(tdu.Metadata, 0);
return TypedArrayParserAsync(tdu, tru, connection, requestSequence); return TypedArrayParserAsync(tdu, tru, connection, requestSequence);
@@ -1498,10 +1498,10 @@ public static class DataDeserializer
//} //}
} }
public static object TypedListParser(ParsedTDU tdu, Warehouse warehouse) public static object TypedListParser(ParsedTdu tdu, Warehouse warehouse)
{ {
// get the type // get the type
var (hdrCs, tru) = TRU.Parse(tdu.Metadata, 0); var (hdrCs, tru) = Tru.Parse(tdu.Metadata, 0);
return TypedArrayParser(tdu, tru, warehouse); return TypedArrayParser(tdu, tru, warehouse);
} }
@@ -1511,7 +1511,7 @@ public static class DataDeserializer
var rt = new AsyncBag<PropertyValue>(); var rt = new AsyncBag<PropertyValue>();
ListParserAsync(new ParsedTDU() { Data = data, Offset = offset, ContentLength = length } ListParserAsync(new ParsedTdu() { Data = data, Offset = offset, ContentLength = length }
, connection, requestSequence).Then(x => , connection, requestSequence).Then(x =>
{ {

276
Esiur/Data/DataSerializer.cs
View File

@@ -17,13 +17,13 @@ public static class DataSerializer
{ {
public delegate byte[] Serializer(object value); public delegate byte[] Serializer(object value);
public static unsafe TDU Int32Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Int32Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (int)value; var v = (int)value;
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
{ {
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
} }
else if (v >= short.MinValue && v <= short.MaxValue) else if (v >= short.MinValue && v <= short.MaxValue)
{ {
@@ -32,7 +32,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((short*)ptr) = (short)v; *((short*)ptr) = (short)v;
return new TDU(TDUIdentifier.Int16, rt, 2); return new Tdu(TduIdentifier.Int16, rt, 2);
} }
else else
{ {
@@ -40,18 +40,18 @@ public static class DataSerializer
var rt = new byte[4]; var rt = new byte[4];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((int*)ptr) = v; *((int*)ptr) = v;
return new TDU(TDUIdentifier.Int32, rt, 4); return new Tdu(TduIdentifier.Int32, rt, 4);
} }
} }
public static unsafe TDU UInt32Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu UInt32Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (uint)value; var v = (uint)value;
if (v <= byte.MaxValue) if (v <= byte.MaxValue)
{ {
// Fits in 1 byte // Fits in 1 byte
return new TDU(TDUIdentifier.UInt8, new byte[] { (byte)v }, 1); return new Tdu(TduIdentifier.UInt8, new byte[] { (byte)v }, 1);
} }
else if (v <= ushort.MaxValue) else if (v <= ushort.MaxValue)
{ {
@@ -60,7 +60,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ushort*)ptr) = (ushort)v; *((ushort*)ptr) = (ushort)v;
return new TDU(TDUIdentifier.UInt16, rt, 2); return new Tdu(TduIdentifier.UInt16, rt, 2);
} }
else else
{ {
@@ -69,18 +69,18 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((uint*)ptr) = v; *((uint*)ptr) = v;
return new TDU(TDUIdentifier.UInt32, rt, 4); return new Tdu(TduIdentifier.UInt32, rt, 4);
} }
} }
public static unsafe TDU Int16Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Int16Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (short)value; var v = (short)value;
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
{ {
// Fits in 1 byte // Fits in 1 byte
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
} }
else else
{ {
@@ -89,18 +89,18 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((short*)ptr) = v; *((short*)ptr) = v;
return new TDU(TDUIdentifier.Int16, rt, 2); return new Tdu(TduIdentifier.Int16, rt, 2);
} }
} }
public static unsafe TDU UInt16Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu UInt16Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (ushort)value; var v = (ushort)value;
if (v <= byte.MaxValue) if (v <= byte.MaxValue)
{ {
// Fits in 1 byte // Fits in 1 byte
return new TDU(TDUIdentifier.UInt8, new byte[] { (byte)v }, 1); return new Tdu(TduIdentifier.UInt8, new byte[] { (byte)v }, 1);
} }
else else
{ {
@@ -109,19 +109,19 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ushort*)ptr) = v; *((ushort*)ptr) = v;
return new TDU(TDUIdentifier.UInt16, rt, 2); return new Tdu(TduIdentifier.UInt16, rt, 2);
} }
} }
public static unsafe TDU Float32Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Float32Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
float v = (float)value; float v = (float)value;
// Special IEEE-754 values // Special IEEE-754 values
if (float.IsNaN(v) || float.IsInfinity(v)) if (float.IsNaN(v) || float.IsInfinity(v))
{ {
return new TDU(TDUIdentifier.Infinity, new byte[0], 0); return new Tdu(TduIdentifier.Infinity, new byte[0], 0);
} }
// If v is an exact integer, prefer smallest signed width up to Int32 // If v is an exact integer, prefer smallest signed width up to Int32
@@ -130,7 +130,7 @@ public static class DataSerializer
// Note: casts are safe because we check bounds first. // Note: casts are safe because we check bounds first.
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
{ {
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
} }
if (v >= short.MinValue && v <= short.MaxValue) if (v >= short.MinValue && v <= short.MaxValue)
@@ -138,7 +138,7 @@ public static class DataSerializer
var rt = new byte[2]; var rt = new byte[2];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((short*)ptr) = (short)v; *((short*)ptr) = (short)v;
return new TDU(TDUIdentifier.Int16, rt, 2); return new Tdu(TduIdentifier.Int16, rt, 2);
} }
} }
@@ -147,26 +147,26 @@ public static class DataSerializer
var rt = new byte[4]; var rt = new byte[4];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((float*)ptr) = v; *((float*)ptr) = v;
return new TDU(TDUIdentifier.Float32, rt, 4); return new Tdu(TduIdentifier.Float32, rt, 4);
} }
} }
public unsafe static TDU Float64Composer(object value, Warehouse warehouse, EpConnection connection) public unsafe static Tdu Float64Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
double v = (double)value; double v = (double)value;
// Special IEEE-754 values // Special IEEE-754 values
if (double.IsNaN(v) || double.IsInfinity(v)) if (double.IsNaN(v) || double.IsInfinity(v))
{ {
return new TDU(TDUIdentifier.Infinity, new byte[0], 0); return new Tdu(TduIdentifier.Infinity, new byte[0], 0);
} }
// If v is an exact integer, choose the smallest signed width // If v is an exact integer, choose the smallest signed width
if (v == Math.Truncate(v)) if (v == Math.Truncate(v))
{ {
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
if (v >= short.MinValue && v <= short.MaxValue) if (v >= short.MinValue && v <= short.MaxValue)
{ {
@@ -175,7 +175,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((short*)ptr) = (short)v; *((short*)ptr) = (short)v;
return new TDU(TDUIdentifier.Int16, rt, 2); return new Tdu(TduIdentifier.Int16, rt, 2);
} }
if (v >= int.MinValue && v <= int.MaxValue) if (v >= int.MinValue && v <= int.MaxValue)
@@ -185,7 +185,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((int*)ptr) = (int)v; *((int*)ptr) = (int)v;
return new TDU(TDUIdentifier.Int32, rt, 4); return new Tdu(TduIdentifier.Int32, rt, 4);
} }
// If it's integral but outside Int64 range, fall through to Float64. // If it's integral but outside Int64 range, fall through to Float64.
@@ -200,7 +200,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((float*)ptr) = f; *((float*)ptr) = f;
return new TDU(TDUIdentifier.Float32, rt, 4); return new Tdu(TduIdentifier.Float32, rt, 4);
} }
// Default: Float64 // Default: Float64
@@ -208,17 +208,17 @@ public static class DataSerializer
var rt = new byte[8]; var rt = new byte[8];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((double*)ptr) = v; *((double*)ptr) = v;
return new TDU(TDUIdentifier.Float64, rt, 8); return new Tdu(TduIdentifier.Float64, rt, 8);
} }
} }
public static unsafe TDU Int64Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Int64Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (long)value; var v = (long)value;
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
{ {
// Fits in 1 byte // Fits in 1 byte
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
} }
else if (v >= short.MinValue && v <= short.MaxValue) else if (v >= short.MinValue && v <= short.MaxValue)
{ {
@@ -227,7 +227,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((short*)ptr) = (short)v; *((short*)ptr) = (short)v;
return new TDU(TDUIdentifier.Int16, rt, 2); return new Tdu(TduIdentifier.Int16, rt, 2);
} }
else if (v >= int.MinValue && v <= int.MaxValue) else if (v >= int.MinValue && v <= int.MaxValue)
{ {
@@ -236,7 +236,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((int*)ptr) = (int)v; *((int*)ptr) = (int)v;
return new TDU(TDUIdentifier.Int32, rt, 4); return new Tdu(TduIdentifier.Int32, rt, 4);
} }
else else
{ {
@@ -245,18 +245,18 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((long*)ptr) = v; *((long*)ptr) = v;
return new TDU(TDUIdentifier.Int64, rt, 8); return new Tdu(TduIdentifier.Int64, rt, 8);
} }
} }
public static unsafe TDU UInt64Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu UInt64Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (ulong)value; var v = (ulong)value;
if (v <= byte.MaxValue) if (v <= byte.MaxValue)
{ {
// Fits in 1 byte // Fits in 1 byte
return new TDU(TDUIdentifier.UInt8, new byte[] { (byte)v }, 1); return new Tdu(TduIdentifier.UInt8, new byte[] { (byte)v }, 1);
} }
else if (v <= ushort.MaxValue) else if (v <= ushort.MaxValue)
{ {
@@ -265,7 +265,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ushort*)ptr) = (ushort)v; *((ushort*)ptr) = (ushort)v;
return new TDU(TDUIdentifier.UInt16, rt, 2); return new Tdu(TduIdentifier.UInt16, rt, 2);
} }
else if (v <= uint.MaxValue) else if (v <= uint.MaxValue)
{ {
@@ -274,7 +274,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((uint*)ptr) = (uint)v; *((uint*)ptr) = (uint)v;
return new TDU(TDUIdentifier.UInt32, rt, 4); return new Tdu(TduIdentifier.UInt32, rt, 4);
} }
else else
{ {
@@ -283,19 +283,19 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ulong*)ptr) = v; *((ulong*)ptr) = v;
return new TDU(TDUIdentifier.UInt64, rt, 8); return new Tdu(TduIdentifier.UInt64, rt, 8);
} }
} }
public static unsafe TDU DateTimeComposer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu DateTimeComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = ((DateTime)value).ToUniversalTime().Ticks; var v = ((DateTime)value).ToUniversalTime().Ticks;
var rt = new byte[8]; var rt = new byte[8];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((long*)ptr) = v; *((long*)ptr) = v;
return new TDU(TDUIdentifier.DateTime, rt, 8); return new Tdu(TduIdentifier.DateTime, rt, 8);
} }
//public static unsafe TDU Decimal128Composer(object value, Warehouse warehouse, EpConnection connection) //public static unsafe TDU Decimal128Composer(object value, Warehouse warehouse, EpConnection connection)
@@ -308,7 +308,7 @@ public static class DataSerializer
// return new TDU(TDUIdentifier.Decimal128, rt, 16); // return new TDU(TDUIdentifier.Decimal128, rt, 16);
//} //}
public static unsafe TDU Decimal128Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Decimal128Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (decimal)value; var v = (decimal)value;
@@ -320,27 +320,27 @@ public static class DataSerializer
if (scale == 0) if (scale == 0)
{ {
if (v >= sbyte.MinValue && v <= sbyte.MaxValue) if (v >= sbyte.MinValue && v <= sbyte.MaxValue)
return new TDU(TDUIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1); return new Tdu(TduIdentifier.Int8, new byte[] { (byte)(sbyte)v }, 1);
if (v >= short.MinValue && v <= short.MaxValue) if (v >= short.MinValue && v <= short.MaxValue)
{ {
var b = new byte[2]; var b = new byte[2];
BinaryPrimitives.WriteInt16LittleEndian(b, (short)v); BinaryPrimitives.WriteInt16LittleEndian(b, (short)v);
return new TDU(TDUIdentifier.Int16, b, 2); return new Tdu(TduIdentifier.Int16, b, 2);
} }
if (v >= int.MinValue && v <= int.MaxValue) if (v >= int.MinValue && v <= int.MaxValue)
{ {
var b = new byte[4]; var b = new byte[4];
BinaryPrimitives.WriteInt32LittleEndian(b, (int)v); BinaryPrimitives.WriteInt32LittleEndian(b, (int)v);
return new TDU(TDUIdentifier.Int32, b, 4); return new Tdu(TduIdentifier.Int32, b, 4);
} }
if (v >= long.MinValue && v <= long.MaxValue) if (v >= long.MinValue && v <= long.MaxValue)
{ {
var b = new byte[8]; var b = new byte[8];
BinaryPrimitives.WriteInt64LittleEndian(b, (long)v); BinaryPrimitives.WriteInt64LittleEndian(b, (long)v);
return new TDU(TDUIdentifier.Int64, b, 8); return new Tdu(TduIdentifier.Int64, b, 8);
} }
// else fall through (needs 96+ bits) // else fall through (needs 96+ bits)
} }
@@ -355,7 +355,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((float*)ptr) = f; *((float*)ptr) = f;
return new TDU(TDUIdentifier.Float32, rt, 4); return new Tdu(TduIdentifier.Float32, rt, 4);
} }
// Try exact Float64 (8 bytes) // Try exact Float64 (8 bytes)
@@ -367,7 +367,7 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((double*)ptr) = d; *((double*)ptr) = d;
return new TDU(TDUIdentifier.Float64, rt, 8); return new Tdu(TduIdentifier.Float64, rt, 8);
} }
{ {
@@ -377,29 +377,29 @@ public static class DataSerializer
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((decimal*)ptr) = v; *((decimal*)ptr) = v;
return new TDU(TDUIdentifier.Decimal128, rt, 16); return new Tdu(TduIdentifier.Decimal128, rt, 16);
} }
} }
public static TDU StringComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu StringComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var b = Encoding.UTF8.GetBytes((string)value); var b = Encoding.UTF8.GetBytes((string)value);
return new TDU(TDUIdentifier.String, b, (uint)b.Length); return new Tdu(TduIdentifier.String, b, (uint)b.Length);
} }
public static TDU ResourceLinkComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu ResourceLinkComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var b = Encoding.UTF8.GetBytes((ResourceLink)value); var b = Encoding.UTF8.GetBytes((ResourceLink)value);
return new TDU(TDUIdentifier.ResourceLink, b, (uint)b.Length); return new Tdu(TduIdentifier.ResourceLink, b, (uint)b.Length);
} }
public static TDU EnumComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu EnumComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
//var warehouse = connection?.Instance?.Warehouse ?? connection?.Server?.Instance?.Warehouse; //var warehouse = connection?.Instance?.Warehouse ?? connection?.Server?.Instance?.Warehouse;
@@ -413,71 +413,71 @@ public static class DataSerializer
var ct = typeDef.Constants.FirstOrDefault(x => x.Value.Equals(intVal)); var ct = typeDef.Constants.FirstOrDefault(x => x.Value.Equals(intVal));
if (ct == null) if (ct == null)
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
//return Codec.ComposeInternal(intVal, warehouse, connection); //return Codec.ComposeInternal(intVal, warehouse, connection);
return new TDU(TDUIdentifier.TypedEnum, return new Tdu(TduIdentifier.TypedEnum,
new byte[] { ct.Index }, 1, typeDef.Id.Data); new byte[] { ct.Index }, 1, typeDef.Id.Data);
} }
public static TDU UInt8Composer(object value, Warehouse warehouse, EpConnection connection) public static Tdu UInt8Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
return new TDU(TDUIdentifier.UInt8, return new Tdu(TduIdentifier.UInt8,
new byte[] { (byte)value }, 1); new byte[] { (byte)value }, 1);
} }
public static TDU Int8Composer(object value, Warehouse warehouse, EpConnection connection) public static Tdu Int8Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
return new TDU(TDUIdentifier.Int8, return new Tdu(TduIdentifier.Int8,
new byte[] { (byte)(sbyte)value }, 1); new byte[] { (byte)(sbyte)value }, 1);
} }
public static TDU Char8Composer(object value, Warehouse warehouse, EpConnection connection) public static Tdu Char8Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
return new TDU(TDUIdentifier.Int8, return new Tdu(TduIdentifier.Int8,
new byte[] { (byte)(char)value }, 1); new byte[] { (byte)(char)value }, 1);
} }
public static unsafe TDU Char16Composer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu Char16Composer(object value, Warehouse warehouse, EpConnection connection)
{ {
var v = (char)value; var v = (char)value;
var rt = new byte[2]; var rt = new byte[2];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((char*)ptr) = v; *((char*)ptr) = v;
return new TDU(TDUIdentifier.Char16, rt, 2); return new Tdu(TduIdentifier.Char16, rt, 2);
} }
public static TDU BoolComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu BoolComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if ((bool)value) if ((bool)value)
{ {
return new TDU(TDUIdentifier.True, null, 0); return new Tdu(TduIdentifier.True, null, 0);
} }
else else
{ {
return new TDU(TDUIdentifier.False, null, 0); return new Tdu(TduIdentifier.False, null, 0);
} }
} }
public static TDU NotModifiedComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu NotModifiedComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
return new TDU(TDUIdentifier.NotModified, null, 0); return new Tdu(TduIdentifier.NotModified, null, 0);
} }
public static TDU RawDataComposerFromArray(object value, Warehouse warehouse, EpConnection connection) public static Tdu RawDataComposerFromArray(object value, Warehouse warehouse, EpConnection connection)
{ {
var b = (byte[])value; var b = (byte[])value;
return new TDU(TDUIdentifier.RawData, b, (uint)b.Length); return new Tdu(TduIdentifier.RawData, b, (uint)b.Length);
} }
public static TDU RawDataComposerFromList(dynamic value, Warehouse warehouse, EpConnection connection) public static Tdu RawDataComposerFromList(dynamic value, Warehouse warehouse, EpConnection connection)
{ {
var b = value as List<byte>; var b = value as List<byte>;
return new TDU(TDUIdentifier.RawData, b.ToArray(), (uint)b.Count); return new Tdu(TduIdentifier.RawData, b.ToArray(), (uint)b.Count);
} }
//public static (TDUIdentifier, byte[]) ListComposerFromArray(dynamic value, EpConnection connection) //public static (TDUIdentifier, byte[]) ListComposerFromArray(dynamic value, EpConnection connection)
@@ -491,16 +491,16 @@ public static class DataSerializer
// return (TDUIdentifier.List, rt.ToArray()); // return (TDUIdentifier.List, rt.ToArray());
//} //}
public static TDU ListComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu ListComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection); var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection);
if (composed == null) if (composed == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
else else
{ {
return new TDU(TDUIdentifier.List, composed, (uint)composed.Length); return new Tdu(TduIdentifier.List, composed, (uint)composed.Length);
} }
//if (value == null) //if (value == null)
@@ -534,7 +534,7 @@ public static class DataSerializer
//return new TDU(TDUIdentifier.List, rt.ToArray(), (uint)rt.Count); //return new TDU(TDUIdentifier.List, rt.ToArray(), (uint)rt.Count);
} }
public static byte[] TypedArrayComposer(IEnumerable value, TRU tru, Warehouse warehouse, EpConnection connection) public static byte[] TypedArrayComposer(IEnumerable value, Tru tru, Warehouse warehouse, EpConnection connection)
{ {
byte[] composed; byte[] composed;
@@ -542,31 +542,31 @@ public static class DataSerializer
return null; return null;
if (tru.Identifier == TRUIdentifier.Int32) if (tru.Identifier == TruIdentifier.Int32)
{ {
composed = GroupInt32Codec.Encode((IList<int>)value); composed = GroupInt32Codec.Encode((IList<int>)value);
} }
else if (tru.Identifier == TRUIdentifier.Int64) else if (tru.Identifier == TruIdentifier.Int64)
{ {
composed = GroupInt64Codec.Encode((IList<long>)value); composed = GroupInt64Codec.Encode((IList<long>)value);
} }
else if (tru.Identifier == TRUIdentifier.Int16) else if (tru.Identifier == TruIdentifier.Int16)
{ {
composed = GroupInt16Codec.Encode((IList<short>)value); composed = GroupInt16Codec.Encode((IList<short>)value);
} }
else if (tru.Identifier == TRUIdentifier.UInt32) else if (tru.Identifier == TruIdentifier.UInt32)
{ {
composed = GroupUInt32Codec.Encode((IList<uint>)value); composed = GroupUInt32Codec.Encode((IList<uint>)value);
} }
else if (tru.Identifier == TRUIdentifier.UInt64) else if (tru.Identifier == TruIdentifier.UInt64)
{ {
composed = GroupUInt64Codec.Encode((IList<ulong>)value); composed = GroupUInt64Codec.Encode((IList<ulong>)value);
} }
else if (tru.Identifier == TRUIdentifier.UInt16) else if (tru.Identifier == TruIdentifier.UInt16)
{ {
composed = GroupUInt16Codec.Encode((IList<ushort>)value); composed = GroupUInt16Codec.Encode((IList<ushort>)value);
} }
else if (tru.Identifier == TRUIdentifier.Enum) else if (tru.Identifier == TruIdentifier.Enum)
{ {
var rt = new List<byte>(); var rt = new List<byte>();
@@ -587,21 +587,21 @@ public static class DataSerializer
{ {
var rt = new List<byte>(); var rt = new List<byte>();
TDU? previous = null; Tdu? previous = null;
var isTyped = tru.IsTyped(); var isTyped = tru.IsTyped();
foreach (var i in value) foreach (var i in value)
{ {
var tdu = Codec.ComposeInternal(i, warehouse, connection); var tdu = Codec.ComposeInternal(i, warehouse, connection);
var currentTru = TRU.FromType(i?.GetType()); var currentTru = Tru.FromType(i?.GetType());
if (isTyped && tru.Match(currentTru)) if (isTyped && tru.Match(currentTru))
{ {
var d = tdu.Composed.Clip(tdu.ContentOffset, var d = tdu.Composed.Clip(tdu.ContentOffset,
(uint)tdu.Composed.Length - tdu.ContentOffset); (uint)tdu.Composed.Length - tdu.ContentOffset);
var ntd = new TDU(TDUIdentifier.TypeOfTarget, d, (ulong)d.Length); var ntd = new Tdu(TduIdentifier.TypeOfTarget, d, (ulong)d.Length);
rt.AddRange(ntd.Composed); rt.AddRange(ntd.Composed);
} }
else else
@@ -611,7 +611,7 @@ public static class DataSerializer
var d = tdu.Composed.Clip(tdu.ContentOffset, var d = tdu.Composed.Clip(tdu.ContentOffset,
(uint)tdu.Composed.Length - tdu.ContentOffset); (uint)tdu.Composed.Length - tdu.ContentOffset);
var ntd = new TDU(TDUIdentifier.TypeContinuation, d, (ulong)d.Length); var ntd = new Tdu(TduIdentifier.TypeContinuation, d, (ulong)d.Length);
rt.AddRange(ntd.Composed); rt.AddRange(ntd.Composed);
} }
else else
@@ -630,18 +630,18 @@ public static class DataSerializer
} }
public static TDU TypedListComposer(IEnumerable value, Type type, Warehouse warehouse, EpConnection connection) public static Tdu TypedListComposer(IEnumerable value, Type type, Warehouse warehouse, EpConnection connection)
{ {
var tru = TRU.FromType(type); var tru = Tru.FromType(type);
byte[] composed = TypedArrayComposer(value, tru, warehouse, connection); byte[] composed = TypedArrayComposer(value, tru, warehouse, connection);
if (composed == null) if (composed == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var metadata = tru.Compose(); var metadata = tru.Compose();
return new TDU(TDUIdentifier.TypedList, composed, (uint)composed.Length, metadata); return new Tdu(TduIdentifier.TypedList, composed, (uint)composed.Length, metadata);
} }
//public static byte[] PropertyValueComposer(PropertyValue propertyValue, EpConnection connection)//, bool includeAge = true) //public static byte[] PropertyValueComposer(PropertyValue propertyValue, EpConnection connection)//, bool includeAge = true)
@@ -655,10 +655,10 @@ public static class DataSerializer
// .ToArray(); // .ToArray();
//} //}
public static TDU PropertyValueArrayComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu PropertyValueArrayComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var rt = new List<byte>(); var rt = new List<byte>();
var ar = value as PropertyValue[]; var ar = value as PropertyValue[];
@@ -670,17 +670,17 @@ public static class DataSerializer
rt.AddRange(Codec.Compose(pv.Value, warehouse, connection)); rt.AddRange(Codec.Compose(pv.Value, warehouse, connection));
} }
return new TDU(TDUIdentifier.RawData, rt.ToArray(), return new Tdu(TduIdentifier.RawData, rt.ToArray(),
(uint)rt.Count); (uint)rt.Count);
} }
public static TDU TypedMapComposer(object value, Type keyType, Type valueType, Warehouse warehouse, EpConnection connection) public static Tdu TypedMapComposer(object value, Type keyType, Type valueType, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var kt = TRU.FromType(keyType); var kt = Tru.FromType(keyType);
var vt = TRU.FromType(valueType); var vt = Tru.FromType(valueType);
//var rt = new List<byte>(); //var rt = new List<byte>();
@@ -700,26 +700,26 @@ public static class DataSerializer
//foreach (var el in map.Serialize()) //foreach (var el in map.Serialize())
// rt.AddRange(Codec.Compose(el, warehouse, connection)); // rt.AddRange(Codec.Compose(el, warehouse, connection));
var keysTdu = new TDU(TDUIdentifier.TypeOfTarget, compsedKeys, (uint)compsedKeys.Length).Composed; var keysTdu = new Tdu(TduIdentifier.TypeOfTarget, compsedKeys, (uint)compsedKeys.Length).Composed;
var valuesTdu = new TDU(TDUIdentifier.TypeOfTarget, compsedValues, (uint)compsedValues.Length).Composed; var valuesTdu = new Tdu(TduIdentifier.TypeOfTarget, compsedValues, (uint)compsedValues.Length).Composed;
var all = DC.Combine(keysTdu, 0, (uint)keysTdu.Length, valuesTdu, 0, (uint)valuesTdu.Length); var all = DC.Combine(keysTdu, 0, (uint)keysTdu.Length, valuesTdu, 0, (uint)valuesTdu.Length);
return new TDU(TDUIdentifier.TypedMap, all, (uint)all.Length, metadata); return new Tdu(TduIdentifier.TypedMap, all, (uint)all.Length, metadata);
//return new TDU(TDUIdentifier.TypedMap, rt.ToArray(), (uint)rt.Count, //return new TDU(TDUIdentifier.TypedMap, rt.ToArray(), (uint)rt.Count,
// ); // );
} }
public static TDU TypedDictionaryComposer(object value, Type keyType, Type valueType, Warehouse warehouse, EpConnection connection) public static Tdu TypedDictionaryComposer(object value, Type keyType, Type valueType, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var kt = TRU.FromType(keyType); var kt = Tru.FromType(keyType);
var vt = TRU.FromType(valueType); var vt = Tru.FromType(valueType);
//var rt = new List<byte>(); //var rt = new List<byte>();
@@ -739,12 +739,12 @@ public static class DataSerializer
//foreach (var el in map.Serialize()) //foreach (var el in map.Serialize())
// rt.AddRange(Codec.Compose(el, warehouse, connection)); // rt.AddRange(Codec.Compose(el, warehouse, connection));
var keysTdu = new TDU(TDUIdentifier.TypeOfTarget, compsedKeys, (uint)compsedKeys.Length).Composed; var keysTdu = new Tdu(TduIdentifier.TypeOfTarget, compsedKeys, (uint)compsedKeys.Length).Composed;
var valuesTdu = new TDU(TDUIdentifier.TypeOfTarget, compsedValues, (uint)compsedValues.Length).Composed; var valuesTdu = new Tdu(TduIdentifier.TypeOfTarget, compsedValues, (uint)compsedValues.Length).Composed;
var all = DC.Combine(keysTdu, 0, (uint)keysTdu.Length, valuesTdu, 0, (uint)valuesTdu.Length); var all = DC.Combine(keysTdu, 0, (uint)keysTdu.Length, valuesTdu, 0, (uint)valuesTdu.Length);
return new TDU(TDUIdentifier.TypedMap, all, (uint)all.Length, metadata); return new Tdu(TduIdentifier.TypedMap, all, (uint)all.Length, metadata);
//if (value == null) //if (value == null)
@@ -782,7 +782,7 @@ public static class DataSerializer
var rt = new List<byte>(); var rt = new List<byte>();
TDU? previous = null; Tdu? previous = null;
foreach (var i in value) foreach (var i in value)
{ {
@@ -792,7 +792,7 @@ public static class DataSerializer
var d = tdu.Composed.Clip(tdu.ContentOffset, var d = tdu.Composed.Clip(tdu.ContentOffset,
(uint)tdu.Composed.Length - tdu.ContentOffset); (uint)tdu.Composed.Length - tdu.ContentOffset);
var ntd = new TDU(TDUIdentifier.TypeContinuation, d, (ulong)d.Length); var ntd = new Tdu(TduIdentifier.TypeContinuation, d, (ulong)d.Length);
rt.AddRange(ntd.Composed); rt.AddRange(ntd.Composed);
} }
else else
@@ -806,36 +806,36 @@ public static class DataSerializer
return rt.ToArray(); return rt.ToArray();
} }
public static TDU ResourceListComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu ResourceListComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection); var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection);
return new TDU(TDUIdentifier.ResourceList, composed, return new Tdu(TduIdentifier.ResourceList, composed,
(uint)composed.Length); (uint)composed.Length);
} }
public static TDU RecordListComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu RecordListComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection); var composed = DynamicArrayComposer((IEnumerable)value, warehouse, connection);
return new TDU(TDUIdentifier.RecordList, return new Tdu(TduIdentifier.RecordList,
composed, (uint)composed.Length); composed, (uint)composed.Length);
} }
public static unsafe TDU ResourceComposer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu ResourceComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var resource = (IResource)value; var resource = (IResource)value;
if (resource.Instance == null || resource.Instance.IsDestroyed) if (resource.Instance == null || resource.Instance.IsDestroyed)
{ {
return new TDU(TDUIdentifier.Null, null, 0); return new Tdu(TduIdentifier.Null, null, 0);
} }
if (Codec.IsLocalResource(resource, connection)) if (Codec.IsLocalResource(resource, connection))
@@ -843,21 +843,21 @@ public static class DataSerializer
var rid = (resource as EpResource).DistributedResourceInstanceId; var rid = (resource as EpResource).DistributedResourceInstanceId;
if (rid <= 0xFF) if (rid <= 0xFF)
return new TDU(TDUIdentifier.LocalResource8, new byte[] { (byte)rid }, 1); return new Tdu(TduIdentifier.LocalResource8, new byte[] { (byte)rid }, 1);
else if (rid <= 0xFFFF) else if (rid <= 0xFFFF)
{ {
var rt = new byte[2]; var rt = new byte[2];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ushort*)ptr) = (ushort)rid; *((ushort*)ptr) = (ushort)rid;
return new TDU(TDUIdentifier.LocalResource16, rt, 2); return new Tdu(TduIdentifier.LocalResource16, rt, 2);
} }
else else
{ {
var rt = new byte[4]; var rt = new byte[4];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((uint*)ptr) = rid; *((uint*)ptr) = rid;
return new TDU(TDUIdentifier.LocalResource32, rt, 4); return new Tdu(TduIdentifier.LocalResource32, rt, 4);
} }
} }
else else
@@ -868,29 +868,29 @@ public static class DataSerializer
var rid = resource.Instance.Id; var rid = resource.Instance.Id;
if (rid <= 0xFF) if (rid <= 0xFF)
return new TDU(TDUIdentifier.RemoteResource8, new byte[] { (byte)rid }, 1); return new Tdu(TduIdentifier.RemoteResource8, new byte[] { (byte)rid }, 1);
else if (rid <= 0xFFFF) else if (rid <= 0xFFFF)
{ {
var rt = new byte[2]; var rt = new byte[2];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((ushort*)ptr) = (ushort)rid; *((ushort*)ptr) = (ushort)rid;
return new TDU(TDUIdentifier.RemoteResource16, rt, 2); return new Tdu(TduIdentifier.RemoteResource16, rt, 2);
} }
else else
{ {
var rt = new byte[4]; var rt = new byte[4];
fixed (byte* ptr = rt) fixed (byte* ptr = rt)
*((uint*)ptr) = rid; *((uint*)ptr) = rid;
return new TDU(TDUIdentifier.RemoteResource32, rt, 4); return new Tdu(TduIdentifier.RemoteResource32, rt, 4);
} }
} }
} }
public static unsafe TDU MapComposer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu MapComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 1); return new Tdu(TduIdentifier.Null, new byte[0], 1);
var rt = new List<byte>(); var rt = new List<byte>();
var map = (IMap)value; var map = (IMap)value;
@@ -898,16 +898,16 @@ public static class DataSerializer
foreach (var el in map.Serialize()) foreach (var el in map.Serialize())
rt.AddRange(Codec.Compose(el, warehouse, connection)); rt.AddRange(Codec.Compose(el, warehouse, connection));
return new TDU(TDUIdentifier.Map, rt.ToArray(), (uint)rt.Count); return new Tdu(TduIdentifier.Map, rt.ToArray(), (uint)rt.Count);
} }
public static unsafe TDU UUIDComposer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu UUIDComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
return new TDU(TDUIdentifier.UUID, ((UUID)value).Data, 16); return new Tdu(TduIdentifier.UUID, ((Uuid)value).Data, 16);
} }
public static unsafe TDU RecordComposer(object value, Warehouse warehouse, EpConnection connection) public static unsafe Tdu RecordComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
var rt = new List<byte>(); var rt = new List<byte>();
var record = (IRecord)value; var record = (IRecord)value;
@@ -921,7 +921,7 @@ public static class DataSerializer
//if (propValue == null) //if (propValue == null)
// return TDU(TDUIdentifier.Null, null, 0); // return TDU(TDUIdentifier.Null, null, 0);
var tru = TRU.FromType(propValue?.GetType()); var tru = Tru.FromType(propValue?.GetType());
var tdu = Codec.ComposeInternal(propValue, warehouse, connection); var tdu = Codec.ComposeInternal(propValue, warehouse, connection);
@@ -930,14 +930,14 @@ public static class DataSerializer
{ {
// strip metadata // strip metadata
var len = (uint)tdu.Composed.Length - tdu.ContentOffset; var len = (uint)tdu.Composed.Length - tdu.ContentOffset;
tdu = new TDU(TDUIdentifier.TypeOfTarget, tdu = new Tdu(TduIdentifier.TypeOfTarget,
tdu.Composed.Clip(tdu.ContentOffset, len), len); tdu.Composed.Clip(tdu.ContentOffset, len), len);
} }
rt.AddRange(tdu.Composed); rt.AddRange(tdu.Composed);
} }
return new TDU(TDUIdentifier.Record, rt.ToArray(), return new Tdu(TduIdentifier.Record, rt.ToArray(),
(uint)rt.Count, (uint)rt.Count,
typeDef.Id.Data); typeDef.Id.Data);
} }
@@ -958,14 +958,14 @@ public static class DataSerializer
return rt.ToArray(); return rt.ToArray();
} }
public static TDU TupleComposer(object value, Warehouse warehouse, EpConnection connection) public static Tdu TupleComposer(object value, Warehouse warehouse, EpConnection connection)
{ {
if (value == null) if (value == null)
return new TDU(TDUIdentifier.Null, new byte[0], 0); return new Tdu(TduIdentifier.Null, new byte[0], 0);
var fields = value.GetType().GetFields(); var fields = value.GetType().GetFields();
var list = fields.Select(x => x.GetValue(value)).ToArray(); var list = fields.Select(x => x.GetValue(value)).ToArray();
var trus = fields.Select(x => TRU.FromType(x.FieldType)).ToArray(); var trus = fields.Select(x => Tru.FromType(x.FieldType)).ToArray();
var metadata = new List<byte>(); var metadata = new List<byte>();
@@ -982,21 +982,21 @@ public static class DataSerializer
var tdu = Codec.ComposeInternal(tupleValue, warehouse, connection); var tdu = Codec.ComposeInternal(tupleValue, warehouse, connection);
var valueTru = TRU.FromType(tupleValue?.GetType()); var valueTru = Tru.FromType(tupleValue?.GetType());
if (targetTru.IsTyped() && if (targetTru.IsTyped() &&
targetTru.Match(valueTru)) targetTru.Match(valueTru))
{ {
// strip metadata // strip metadata
var len = (uint)tdu.Composed.Length - tdu.ContentOffset; var len = (uint)tdu.Composed.Length - tdu.ContentOffset;
tdu = new TDU(TDUIdentifier.TypeOfTarget, tdu = new Tdu(TduIdentifier.TypeOfTarget,
tdu.Composed.Clip(tdu.ContentOffset, len), len); tdu.Composed.Clip(tdu.ContentOffset, len), len);
} }
rt.AddRange(tdu.Composed); rt.AddRange(tdu.Composed);
} }
return new TDU(TDUIdentifier.TypedTuple, rt.ToArray(), return new Tdu(TduIdentifier.TypedTuple, rt.ToArray(),
(uint)rt.Count, metadata.ToArray()); (uint)rt.Count, metadata.ToArray());
} }

50
Esiur/Data/ParsedTDU.cs
View File

@@ -4,11 +4,11 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
public struct ParsedTDU public struct ParsedTdu
{ {
public TDUIdentifier Identifier; public TduIdentifier Identifier;
public int Index; public int Index;
public TDUClass Class; public TduClass Class;
public uint Offset; public uint Offset;
public ulong ContentLength; public ulong ContentLength;
public byte[] Data; public byte[] Data;
@@ -17,21 +17,21 @@ namespace Esiur.Data
public byte[] Metadata; public byte[] Metadata;
public uint Ends; public uint Ends;
public static ParsedTDU Parse(byte[] data, uint offset, uint ends) public static ParsedTdu Parse(byte[] data, uint offset, uint ends)
{ {
var h = data[offset++]; var h = data[offset++];
var cls = (TDUClass)(h >> 6); var cls = (TduClass)(h >> 6);
if (cls == TDUClass.Fixed) if (cls == TduClass.Fixed)
{ {
var exp = (h & 0x38) >> 3; var exp = (h & 0x38) >> 3;
if (exp == 0) if (exp == 0)
return new ParsedTDU() return new ParsedTdu()
{ {
Identifier = (TDUIdentifier)h, Identifier = (TduIdentifier)h,
Data = data, Data = data,
Offset = offset, Offset = offset,
Class = cls, Class = cls,
@@ -45,17 +45,17 @@ namespace Esiur.Data
ulong cl = (ulong)(1 << (exp - 1)); ulong cl = (ulong)(1 << (exp - 1));
if (ends - offset < cl) if (ends - offset < cl)
return new ParsedTDU() return new ParsedTdu()
{ {
Class = TDUClass.Invalid, Class = TduClass.Invalid,
TotalLength = (cl - (ends - offset)) TotalLength = (cl - (ends - offset))
}; };
//offset += (uint)cl; //offset += (uint)cl;
return new ParsedTDU() return new ParsedTdu()
{ {
Identifier = (TDUIdentifier)h, Identifier = (TduIdentifier)h,
Data = data, Data = data,
Offset = offset, Offset = offset,
Class = cls, Class = cls,
@@ -66,14 +66,14 @@ namespace Esiur.Data
Ends = ends Ends = ends
}; };
} }
else if (cls == TDUClass.Typed) else if (cls == TduClass.Typed)
{ {
ulong cll = (ulong)(h >> 3) & 0x7; ulong cll = (ulong)(h >> 3) & 0x7;
if (ends - offset < cll) if (ends - offset < cll)
return new ParsedTDU() return new ParsedTdu()
{ {
Class = TDUClass.Invalid, Class = TduClass.Invalid,
TotalLength = (cll - (ends - offset)) TotalLength = (cll - (ends - offset))
}; };
@@ -83,19 +83,19 @@ namespace Esiur.Data
cl = cl << 8 | data[offset++]; cl = cl << 8 | data[offset++];
if (ends - offset < cl) if (ends - offset < cl)
return new ParsedTDU() return new ParsedTdu()
{ {
TotalLength = (cl - (ends - offset)), TotalLength = (cl - (ends - offset)),
Class = TDUClass.Invalid, Class = TduClass.Invalid,
}; };
var metaData = DC.Clip(data, offset + 1, data[offset]); var metaData = DC.Clip(data, offset + 1, data[offset]);
offset += data[offset] + (uint)1; offset += data[offset] + (uint)1;
return new ParsedTDU() return new ParsedTdu()
{ {
Identifier = (TDUIdentifier)(h & 0xC7), Identifier = (TduIdentifier)(h & 0xC7),
Data = data, Data = data,
Offset = offset, Offset = offset,
Class = cls, Class = cls,
@@ -111,9 +111,9 @@ namespace Esiur.Data
ulong cll = (ulong)(h >> 3) & 0x7; ulong cll = (ulong)(h >> 3) & 0x7;
if (ends - offset < cll) if (ends - offset < cll)
return new ParsedTDU() return new ParsedTdu()
{ {
Class = TDUClass.Invalid, Class = TduClass.Invalid,
TotalLength = (cll - (ends - offset)) TotalLength = (cll - (ends - offset))
}; };
@@ -123,17 +123,17 @@ namespace Esiur.Data
cl = cl << 8 | data[offset++]; cl = cl << 8 | data[offset++];
if (ends - offset < cl) if (ends - offset < cl)
return new ParsedTDU() return new ParsedTdu()
{ {
Class = TDUClass.Invalid, Class = TduClass.Invalid,
TotalLength = (cl - (ends - offset)) TotalLength = (cl - (ends - offset))
}; };
return return
new ParsedTDU() new ParsedTdu()
{ {
Identifier = (TDUIdentifier)(h & 0xC7), Identifier = (TduIdentifier)(h & 0xC7),
Data = data, Data = data,
Offset = offset, Offset = offset,
Class = cls, Class = cls,

26
Esiur/Data/TDU.cs
View File

@@ -8,11 +8,11 @@ using static Esiur.Data.Codec;
namespace Esiur.Data; namespace Esiur.Data;
// Transmission Data Unit // Transmission Data Unit
public struct TDU public struct Tdu
{ {
public TDUIdentifier Identifier; public TduIdentifier Identifier;
//public int Index; //public int Index;
public TDUClass Class; public TduClass Class;
//public ulong ContentLength; //public ulong ContentLength;
public byte[] Composed; public byte[] Composed;
@@ -52,35 +52,35 @@ public struct TDU
//private ulong TotalSize; //private ulong TotalSize;
public TDU() public Tdu()
{ {
} }
public TDU(TDUIdentifier identifier) public Tdu(TduIdentifier identifier)
{ {
Identifier = identifier; Identifier = identifier;
Composed = new byte[0]; Composed = new byte[0];
} }
public TDU(TDUIdentifier identifier, public Tdu(TduIdentifier identifier,
byte[] data, ulong length, byte[] metadata = null) byte[] data, ulong length, byte[] metadata = null)
{ {
Identifier = identifier; Identifier = identifier;
//Index = (byte)identifier & 0x7; //Index = (byte)identifier & 0x7;
Class = (TDUClass)((byte)identifier >> 6); Class = (TduClass)((byte)identifier >> 6);
Metadata = metadata; Metadata = metadata;
if (Class == TDUClass.Fixed) if (Class == TduClass.Fixed)
{ {
if (length == 0) if (length == 0)
Composed = new byte[1] { (byte)identifier }; Composed = new byte[1] { (byte)identifier };
else else
Composed = DC.Combine(new byte[] { (byte)Identifier }, 0, 1, data, 0, (uint)length); Composed = DC.Combine(new byte[] { (byte)Identifier }, 0, 1, data, 0, (uint)length);
} }
else if (Class == TDUClass.Dynamic else if (Class == TduClass.Dynamic
|| Class == TDUClass.Extension) || Class == TduClass.Extension)
{ {
if (length == 0) if (length == 0)
@@ -169,7 +169,7 @@ public struct TDU
Buffer.BlockCopy(data, 0, Composed, 8, (int)length); Buffer.BlockCopy(data, 0, Composed, 8, (int)length);
} }
} }
else if (Class == TDUClass.Typed) else if (Class == TduClass.Typed)
{ {
if (metadata == null) if (metadata == null)
throw new Exception("Metadata must be provided for types."); throw new Exception("Metadata must be provided for types.");
@@ -297,12 +297,12 @@ public struct TDU
} }
public bool MatchType(TDU with) public bool MatchType(Tdu with)
{ {
if (Identifier != with.Identifier) if (Identifier != with.Identifier)
return false; return false;
if (Class != TDUClass.Typed || with.Class != TDUClass.Typed) if (Class != TduClass.Typed || with.Class != TduClass.Typed)
return false; return false;
if (!Metadata.SequenceEqual(with.Metadata)) if (!Metadata.SequenceEqual(with.Metadata))

2
Esiur/Data/TDUClass.cs
View File

@@ -4,7 +4,7 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
public enum TDUClass public enum TduClass
{ {
Fixed = 0x0, Fixed = 0x0,
Dynamic = 0x1, Dynamic = 0x1,

2
Esiur/Data/TDUIdentifier.cs
View File

@@ -4,7 +4,7 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
public enum TDUIdentifier public enum TduIdentifier
{ {
Null = 0x0, Null = 0x0,
False = 0x1, False = 0x1,

284
Esiur/Data/TRU.cs
View File

@@ -14,54 +14,54 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
public class TRU public class Tru
{ {
static TRUIdentifier[] refTypes = new TRUIdentifier[] static TruIdentifier[] refTypes = new TruIdentifier[]
{ {
TRUIdentifier.Dynamic, TruIdentifier.Dynamic,
TRUIdentifier.RawData, TruIdentifier.RawData,
TRUIdentifier.String, TruIdentifier.String,
TRUIdentifier.Resource, TruIdentifier.Resource,
TRUIdentifier.Record, TruIdentifier.Record,
TRUIdentifier.Map, TruIdentifier.Map,
TRUIdentifier.List, TruIdentifier.List,
TRUIdentifier.TypedList, TruIdentifier.TypedList,
TRUIdentifier.TypedMap, TruIdentifier.TypedMap,
TRUIdentifier.Tuple2, TruIdentifier.Tuple2,
TRUIdentifier.Tuple3, TruIdentifier.Tuple3,
TRUIdentifier.Tuple4, TruIdentifier.Tuple4,
TRUIdentifier.Tuple5, TruIdentifier.Tuple5,
TRUIdentifier.Tuple6, TruIdentifier.Tuple6,
TRUIdentifier.Tuple7, TruIdentifier.Tuple7,
TRUIdentifier.TypedRecord, TruIdentifier.TypedRecord,
TRUIdentifier.TypedResource TruIdentifier.TypedResource
}; };
static Map<TDUIdentifier, TRUIdentifier> typesMap = new Map<TDUIdentifier, TRUIdentifier>() static Map<TduIdentifier, TruIdentifier> typesMap = new Map<TduIdentifier, TruIdentifier>()
{ {
[TDUIdentifier.UInt8] = TRUIdentifier.UInt8, [TduIdentifier.UInt8] = TruIdentifier.UInt8,
[TDUIdentifier.Int8] = TRUIdentifier.Int8, [TduIdentifier.Int8] = TruIdentifier.Int8,
[TDUIdentifier.UInt16] = TRUIdentifier.UInt16, [TduIdentifier.UInt16] = TruIdentifier.UInt16,
[TDUIdentifier.Int16] = TRUIdentifier.Int16, [TduIdentifier.Int16] = TruIdentifier.Int16,
[TDUIdentifier.UInt32] = TRUIdentifier.UInt32, [TduIdentifier.UInt32] = TruIdentifier.UInt32,
[TDUIdentifier.Int32] = TRUIdentifier.Int32, [TduIdentifier.Int32] = TruIdentifier.Int32,
[TDUIdentifier.UInt64] = TRUIdentifier.UInt64, [TduIdentifier.UInt64] = TruIdentifier.UInt64,
[TDUIdentifier.Int64] = TRUIdentifier.Int64, [TduIdentifier.Int64] = TruIdentifier.Int64,
[TDUIdentifier.UInt128] = TRUIdentifier.UInt128, [TduIdentifier.UInt128] = TruIdentifier.UInt128,
[TDUIdentifier.Int128] = TRUIdentifier.Int128, [TduIdentifier.Int128] = TruIdentifier.Int128,
[TDUIdentifier.Char8] = TRUIdentifier.Char, [TduIdentifier.Char8] = TruIdentifier.Char,
[TDUIdentifier.DateTime] = TRUIdentifier.DateTime, [TduIdentifier.DateTime] = TruIdentifier.DateTime,
[TDUIdentifier.Float32] = TRUIdentifier.Float32, [TduIdentifier.Float32] = TruIdentifier.Float32,
[TDUIdentifier.Float64] = TRUIdentifier.Float64, [TduIdentifier.Float64] = TruIdentifier.Float64,
[TDUIdentifier.Decimal128] = TRUIdentifier.Decimal, [TduIdentifier.Decimal128] = TruIdentifier.Decimal,
[TDUIdentifier.False] = TRUIdentifier.Bool, [TduIdentifier.False] = TruIdentifier.Bool,
[TDUIdentifier.True] = TRUIdentifier.Bool, [TduIdentifier.True] = TruIdentifier.Bool,
[TDUIdentifier.Map] = TRUIdentifier.Map, [TduIdentifier.Map] = TruIdentifier.Map,
[TDUIdentifier.List] = TRUIdentifier.List, [TduIdentifier.List] = TruIdentifier.List,
[TDUIdentifier.RawData] = TRUIdentifier.RawData, [TduIdentifier.RawData] = TruIdentifier.RawData,
[TDUIdentifier.Record] = TRUIdentifier.Record, [TduIdentifier.Record] = TruIdentifier.Record,
[TDUIdentifier.String] = TRUIdentifier.String, [TduIdentifier.String] = TruIdentifier.String,
}; };
@@ -129,7 +129,7 @@ namespace Esiur.Data
public Type? GetRuntimeType(Warehouse warehouse) public Type? GetRuntimeType(Warehouse warehouse)
{ {
if (Identifier == TRUIdentifier.TypedList) if (Identifier == TruIdentifier.TypedList)
{ {
var sub = SubTypes?[0].GetRuntimeType(warehouse); var sub = SubTypes?[0].GetRuntimeType(warehouse);
if (sub == null) if (sub == null)
@@ -139,7 +139,7 @@ namespace Esiur.Data
return rt; return rt;
} }
else if (Identifier == TRUIdentifier.TypedMap) else if (Identifier == TruIdentifier.TypedMap)
{ {
var subs = SubTypes.Select(x => x.GetRuntimeType(warehouse)).ToArray(); var subs = SubTypes.Select(x => x.GetRuntimeType(warehouse)).ToArray();
var rt = typeof(Map<,>).MakeGenericType(subs); var rt = typeof(Map<,>).MakeGenericType(subs);
@@ -148,59 +148,59 @@ namespace Esiur.Data
return Identifier switch return Identifier switch
{ {
(TRUIdentifier.Void) => typeof(void), (TruIdentifier.Void) => typeof(void),
(TRUIdentifier.Dynamic) => typeof(object), (TruIdentifier.Dynamic) => typeof(object),
(TRUIdentifier.Bool) => Nullable ? typeof(bool?) : typeof(bool), (TruIdentifier.Bool) => Nullable ? typeof(bool?) : typeof(bool),
(TRUIdentifier.Char) => Nullable ? typeof(char?) : typeof(char), (TruIdentifier.Char) => Nullable ? typeof(char?) : typeof(char),
(TRUIdentifier.UInt8) => Nullable ? typeof(byte?) : typeof(byte), (TruIdentifier.UInt8) => Nullable ? typeof(byte?) : typeof(byte),
(TRUIdentifier.Int8) => Nullable ? typeof(sbyte?) : typeof(sbyte), (TruIdentifier.Int8) => Nullable ? typeof(sbyte?) : typeof(sbyte),
(TRUIdentifier.Int16) => Nullable ? typeof(short?) : typeof(short), (TruIdentifier.Int16) => Nullable ? typeof(short?) : typeof(short),
(TRUIdentifier.UInt16) => Nullable ? typeof(ushort?) : typeof(ushort), (TruIdentifier.UInt16) => Nullable ? typeof(ushort?) : typeof(ushort),
(TRUIdentifier.Int32) => Nullable ? typeof(int?) : typeof(int), (TruIdentifier.Int32) => Nullable ? typeof(int?) : typeof(int),
(TRUIdentifier.UInt32) => Nullable ? typeof(uint?) : typeof(uint), (TruIdentifier.UInt32) => Nullable ? typeof(uint?) : typeof(uint),
(TRUIdentifier.Int64) => Nullable ? typeof(ulong?) : typeof(long), (TruIdentifier.Int64) => Nullable ? typeof(ulong?) : typeof(long),
(TRUIdentifier.UInt64) => Nullable ? typeof(ulong?) : typeof(ulong), (TruIdentifier.UInt64) => Nullable ? typeof(ulong?) : typeof(ulong),
(TRUIdentifier.Float32) => Nullable ? typeof(float?) : typeof(float), (TruIdentifier.Float32) => Nullable ? typeof(float?) : typeof(float),
(TRUIdentifier.Float64) => Nullable ? typeof(double?) : typeof(double), (TruIdentifier.Float64) => Nullable ? typeof(double?) : typeof(double),
(TRUIdentifier.Decimal) => Nullable ? typeof(decimal?) : typeof(decimal), (TruIdentifier.Decimal) => Nullable ? typeof(decimal?) : typeof(decimal),
(TRUIdentifier.String) => typeof(string), (TruIdentifier.String) => typeof(string),
(TRUIdentifier.DateTime) => Nullable ? typeof(DateTime?) : typeof(DateTime), (TruIdentifier.DateTime) => Nullable ? typeof(DateTime?) : typeof(DateTime),
(TRUIdentifier.Resource) => typeof(IResource), (TruIdentifier.Resource) => typeof(IResource),
(TRUIdentifier.Record) => typeof(IRecord), (TruIdentifier.Record) => typeof(IRecord),
(TRUIdentifier.TypedRecord) => warehouse.GetTypeDefById((UUID)UUID!, TypeDefKind.Record)?.DefinedType, (TruIdentifier.TypedRecord) => warehouse.GetTypeDefById((Uuid)UUID!, TypeDefKind.Record)?.DefinedType,
(TRUIdentifier.TypedResource) => warehouse.GetTypeDefById((UUID)UUID!, TypeDefKind.Resource)?.DefinedType, (TruIdentifier.TypedResource) => warehouse.GetTypeDefById((Uuid)UUID!, TypeDefKind.Resource)?.DefinedType,
(TRUIdentifier.Enum) => warehouse.GetTypeDefById((UUID)UUID!, TypeDefKind.Enum)?.DefinedType, (TruIdentifier.Enum) => warehouse.GetTypeDefById((Uuid)UUID!, TypeDefKind.Enum)?.DefinedType,
_ => null _ => null
}; };
} }
public TRUIdentifier Identifier; public TruIdentifier Identifier;
public bool Nullable; public bool Nullable;
public UUID? UUID; public Uuid? UUID;
//public RepresentationType? SubType1; // List + Map //public RepresentationType? SubType1; // List + Map
//public RepresentationType? SubType2; // Map //public RepresentationType? SubType2; // Map
//public RepresentationType? SubType3; // No types yet //public RepresentationType? SubType3; // No types yet
public TRU[]? SubTypes = null; public Tru[]? SubTypes = null;
public TRU ToNullable() public Tru ToNullable()
{ {
return new TRU(Identifier, true, UUID, SubTypes); return new Tru(Identifier, true, UUID, SubTypes);
} }
public bool IsTyped() public bool IsTyped()
{ {
if (Identifier == TRUIdentifier.TypedList && SubTypes[0].Identifier == TRUIdentifier.UInt8) if (Identifier == TruIdentifier.TypedList && SubTypes[0].Identifier == TruIdentifier.UInt8)
return false; return false;
if (Identifier == TRUIdentifier.TypedResource) if (Identifier == TruIdentifier.TypedResource)
return false; return false;
return (UUID != null) || (SubTypes != null && SubTypes.Length > 0); return (UUID != null) || (SubTypes != null && SubTypes.Length > 0);
} }
public bool Match(TRU other) public bool Match(Tru other)
{ {
//if (UUID == null && (SubTypes == null || SubTypes.Length == 0)) //if (UUID == null && (SubTypes == null || SubTypes.Length == 0))
// return false; // return false;
@@ -224,19 +224,19 @@ namespace Esiur.Data
} }
public (TDUIdentifier, byte[]) GetMetadata() public (TduIdentifier, byte[]) GetMetadata()
{ {
switch (Identifier) switch (Identifier)
{ {
case TRUIdentifier.TypedList: case TruIdentifier.TypedList:
return (TDUIdentifier.TypedList, SubTypes[0].Compose()); return (TduIdentifier.TypedList, SubTypes[0].Compose());
case TRUIdentifier.TypedRecord: case TruIdentifier.TypedRecord:
return (TDUIdentifier.Record, UUID?.Data); return (TduIdentifier.Record, UUID?.Data);
case TRUIdentifier.TypedMap: case TruIdentifier.TypedMap:
return (TDUIdentifier.TypedMap, return (TduIdentifier.TypedMap,
SubTypes[0].Compose().Concat(SubTypes[1].Compose()).ToArray()); SubTypes[0].Compose().Concat(SubTypes[1].Compose()).ToArray());
case TRUIdentifier.Enum: case TruIdentifier.Enum:
return (TDUIdentifier.TypedEnum, UUID?.Data); return (TduIdentifier.TypedEnum, UUID?.Data);
default: default:
@@ -267,12 +267,12 @@ namespace Esiur.Data
// case TRUIdentifier. } // case TRUIdentifier. }
//} //}
private static Dictionary<Type, TRU> _cache = new Dictionary<Type, TRU>(); private static Dictionary<Type, Tru> _cache = new Dictionary<Type, Tru>();
public static TRU? FromType(Type type) public static Tru? FromType(Type type)
{ {
if (type == null) if (type == null)
return new TRU(TRUIdentifier.Void, true); return new Tru(TruIdentifier.Void, true);
if (_cache.ContainsKey(type)) if (_cache.ContainsKey(type))
return _cache[type]; return _cache[type];
@@ -287,33 +287,33 @@ namespace Esiur.Data
nullable = true; nullable = true;
} }
TRU? tru = null; Tru? tru = null;
if (type == typeof(IResource)) if (type == typeof(IResource))
{ {
return new TRU(TRUIdentifier.Resource, nullable); return new Tru(TruIdentifier.Resource, nullable);
} }
else if (type == typeof(IRecord) || type == typeof(Record)) else if (type == typeof(IRecord) || type == typeof(Record))
{ {
return new TRU(TRUIdentifier.Record, nullable); return new Tru(TruIdentifier.Record, nullable);
} }
else if (type == typeof(Map<object, object>) else if (type == typeof(Map<object, object>)
|| type == typeof(Dictionary<object, object>)) || type == typeof(Dictionary<object, object>))
{ {
return new TRU(TRUIdentifier.Map, nullable); return new Tru(TruIdentifier.Map, nullable);
} }
else if (Codec.ImplementsInterface(type, typeof(IResource))) else if (Codec.ImplementsInterface(type, typeof(IResource)))
{ {
tru = new TRU( tru = new Tru(
TRUIdentifier.TypedResource, TruIdentifier.TypedResource,
nullable, nullable,
TypeDef.GetTypeUUID(type) TypeDef.GetTypeUUID(type)
); );
} }
else if (Codec.ImplementsInterface(type, typeof(IRecord))) else if (Codec.ImplementsInterface(type, typeof(IRecord)))
{ {
tru = new TRU( tru = new Tru(
TRUIdentifier.TypedRecord, TruIdentifier.TypedRecord,
nullable, nullable,
TypeDef.GetTypeUUID(type) TypeDef.GetTypeUUID(type)
); );
@@ -329,7 +329,7 @@ namespace Esiur.Data
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
if (args[0] == typeof(object)) if (args[0] == typeof(object))
{ {
tru = new TRU(TRUIdentifier.List, nullable); tru = new Tru(TruIdentifier.List, nullable);
} }
else else
{ {
@@ -338,8 +338,8 @@ namespace Esiur.Data
return null; return null;
tru = new TRU(TRUIdentifier.TypedList, nullable, null, tru = new Tru(TruIdentifier.TypedList, nullable, null,
new TRU[] { subType }); new Tru[] { subType });
} }
} }
@@ -349,7 +349,7 @@ namespace Esiur.Data
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
if (args[0] == typeof(object) && args[1] == typeof(object)) if (args[0] == typeof(object) && args[1] == typeof(object))
{ {
tru = new TRU(TRUIdentifier.Map, nullable); tru = new Tru(TruIdentifier.Map, nullable);
} }
else else
{ {
@@ -361,8 +361,8 @@ namespace Esiur.Data
if (subType2 == null) if (subType2 == null)
return null; return null;
tru = new TRU(TRUIdentifier.TypedMap, nullable, null, tru = new Tru(TruIdentifier.TypedMap, nullable, null,
new TRU[] { subType1, subType2 }); new Tru[] { subType1, subType2 });
} }
} }
@@ -375,7 +375,7 @@ namespace Esiur.Data
else if (genericType == typeof(ValueTuple<,>)) else if (genericType == typeof(ValueTuple<,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -385,13 +385,13 @@ namespace Esiur.Data
} }
tru = new TRU(TRUIdentifier.Tuple2, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple2, nullable, null, subTypes);
} }
else if (genericType == typeof(ValueTuple<,,>)) else if (genericType == typeof(ValueTuple<,,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -400,14 +400,14 @@ namespace Esiur.Data
subTypes[i] = t; subTypes[i] = t;
} }
tru = new TRU(TRUIdentifier.Tuple3, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple3, nullable, null, subTypes);
} }
else if (genericType == typeof(ValueTuple<,,,>)) else if (genericType == typeof(ValueTuple<,,,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -416,12 +416,12 @@ namespace Esiur.Data
subTypes[i] = t; subTypes[i] = t;
} }
tru = new TRU(TRUIdentifier.Tuple4, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple4, nullable, null, subTypes);
} }
else if (genericType == typeof(ValueTuple<,,,,>)) else if (genericType == typeof(ValueTuple<,,,,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -430,12 +430,12 @@ namespace Esiur.Data
subTypes[i] = t; subTypes[i] = t;
} }
tru = new TRU(TRUIdentifier.Tuple5, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple5, nullable, null, subTypes);
} }
else if (genericType == typeof(ValueTuple<,,,,,>)) else if (genericType == typeof(ValueTuple<,,,,,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -444,12 +444,12 @@ namespace Esiur.Data
subTypes[i] = t; subTypes[i] = t;
} }
tru = new TRU(TRUIdentifier.Tuple6, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple6, nullable, null, subTypes);
} }
else if (genericType == typeof(ValueTuple<,,,,,,>)) else if (genericType == typeof(ValueTuple<,,,,,,>))
{ {
var args = type.GetGenericArguments(); var args = type.GetGenericArguments();
var subTypes = new TRU[args.Length]; var subTypes = new Tru[args.Length];
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
{ {
var t = FromType(args[i]); var t = FromType(args[i]);
@@ -458,7 +458,7 @@ namespace Esiur.Data
subTypes[i] = t; subTypes[i] = t;
} }
tru = new TRU(TRUIdentifier.Tuple7, nullable, null, subTypes); tru = new Tru(TruIdentifier.Tuple7, nullable, null, subTypes);
} }
else else
return null; return null;
@@ -467,7 +467,7 @@ namespace Esiur.Data
{ {
var elementType = type.GetElementType(); var elementType = type.GetElementType();
if (elementType == typeof(object)) if (elementType == typeof(object))
tru = new TRU(TRUIdentifier.List, nullable); tru = new Tru(TruIdentifier.List, nullable);
else else
{ {
var subType = FromType(elementType); var subType = FromType(elementType);
@@ -475,14 +475,14 @@ namespace Esiur.Data
if (subType == null) if (subType == null)
return null; return null;
tru = new TRU(TRUIdentifier.TypedList, nullable, null, tru = new Tru(TruIdentifier.TypedList, nullable, null,
new TRU[] { subType }); new Tru[] { subType });
} }
} }
else if (type.IsEnum) else if (type.IsEnum)
{ {
tru = new TRU(TRUIdentifier.Enum, nullable, TypeDef.GetTypeUUID(type)); tru = new Tru(TruIdentifier.Enum, nullable, TypeDef.GetTypeUUID(type));
} }
else if (type.IsInterface) else if (type.IsInterface)
{ {
@@ -503,30 +503,30 @@ namespace Esiur.Data
// last check // last check
return type switch return type switch
{ {
_ when type == typeof(void) => new TRU(TRUIdentifier.Void, nullable), _ when type == typeof(void) => new Tru(TruIdentifier.Void, nullable),
_ when type == typeof(object) => new TRU(TRUIdentifier.Dynamic, nullable), _ when type == typeof(object) => new Tru(TruIdentifier.Dynamic, nullable),
_ when type == typeof(bool) => new TRU(TRUIdentifier.Bool, nullable), _ when type == typeof(bool) => new Tru(TruIdentifier.Bool, nullable),
_ when type == typeof(char) => new TRU(TRUIdentifier.Char, nullable), _ when type == typeof(char) => new Tru(TruIdentifier.Char, nullable),
_ when type == typeof(byte) => new TRU(TRUIdentifier.UInt8, nullable), _ when type == typeof(byte) => new Tru(TruIdentifier.UInt8, nullable),
_ when type == typeof(sbyte) => new TRU(TRUIdentifier.Int8, nullable), _ when type == typeof(sbyte) => new Tru(TruIdentifier.Int8, nullable),
_ when type == typeof(short) => new TRU(TRUIdentifier.Int16, nullable), _ when type == typeof(short) => new Tru(TruIdentifier.Int16, nullable),
_ when type == typeof(ushort) => new TRU(TRUIdentifier.UInt16, nullable), _ when type == typeof(ushort) => new Tru(TruIdentifier.UInt16, nullable),
_ when type == typeof(int) => new TRU(TRUIdentifier.Int32, nullable), _ when type == typeof(int) => new Tru(TruIdentifier.Int32, nullable),
_ when type == typeof(uint) => new TRU(TRUIdentifier.UInt32, nullable), _ when type == typeof(uint) => new Tru(TruIdentifier.UInt32, nullable),
_ when type == typeof(long) => new TRU(TRUIdentifier.Int64, nullable), _ when type == typeof(long) => new Tru(TruIdentifier.Int64, nullable),
_ when type == typeof(ulong) => new TRU(TRUIdentifier.UInt64, nullable), _ when type == typeof(ulong) => new Tru(TruIdentifier.UInt64, nullable),
_ when type == typeof(float) => new TRU(TRUIdentifier.Float32, nullable), _ when type == typeof(float) => new Tru(TruIdentifier.Float32, nullable),
_ when type == typeof(double) => new TRU(TRUIdentifier.Float64, nullable), _ when type == typeof(double) => new Tru(TruIdentifier.Float64, nullable),
_ when type == typeof(decimal) => new TRU(TRUIdentifier.Decimal, nullable), _ when type == typeof(decimal) => new Tru(TruIdentifier.Decimal, nullable),
_ when type == typeof(string) => new TRU(TRUIdentifier.String, nullable), _ when type == typeof(string) => new Tru(TruIdentifier.String, nullable),
_ when type == typeof(DateTime) => new TRU(TRUIdentifier.DateTime, nullable), _ when type == typeof(DateTime) => new Tru(TruIdentifier.DateTime, nullable),
_ when type == typeof(ResourceLink) => new TRU(TRUIdentifier.Resource, nullable), _ when type == typeof(ResourceLink) => new Tru(TruIdentifier.Resource, nullable),
_ => null _ => null
}; };
} }
public TRU(TRUIdentifier identifier, bool nullable, UUID? uuid = null, TRU[]? subTypes = null) public Tru(TruIdentifier identifier, bool nullable, Uuid? uuid = null, Tru[]? subTypes = null)
{ {
Nullable = nullable; Nullable = nullable;
Identifier = identifier; Identifier = identifier;
@@ -553,13 +553,13 @@ namespace Esiur.Data
return rt.ToArray(); return rt.ToArray();
} }
public static (uint, TRU) Parse(byte[] data, uint offset) public static (uint, Tru) Parse(byte[] data, uint offset)
{ {
var oOffset = offset; var oOffset = offset;
var header = data[offset++]; var header = data[offset++];
bool nullable = (header & 0x80) > 0; bool nullable = (header & 0x80) > 0;
var identifier = (TRUIdentifier)(header & 0x7F); var identifier = (TruIdentifier)(header & 0x7F);
if ((header & 0x40) > 0) if ((header & 0x40) > 0)
@@ -568,7 +568,7 @@ namespace Esiur.Data
var hasUUID = (header & 0x4) > 0; var hasUUID = (header & 0x4) > 0;
var subsCount = (header >> 3) & 0x7; var subsCount = (header >> 3) & 0x7;
UUID? uuid = null; Uuid? uuid = null;
if (hasUUID) if (hasUUID)
{ {
@@ -576,19 +576,19 @@ namespace Esiur.Data
offset += 16; offset += 16;
} }
var subs = new TRU[subsCount]; var subs = new Tru[subsCount];
for (var i = 0; i < subsCount; i++) for (var i = 0; i < subsCount; i++)
{ {
(var len, subs[i]) = TRU.Parse(data, offset); (var len, subs[i]) = Tru.Parse(data, offset);
offset += len; offset += len;
} }
return (offset - oOffset, new TRU(identifier, nullable, uuid, subs)); return (offset - oOffset, new Tru(identifier, nullable, uuid, subs));
} }
else else
{ {
return (1, new TRU(identifier, nullable)); return (1, new Tru(identifier, nullable));
} }
} }

2
Esiur/Data/TRUIdentifier.cs
View File

@@ -4,7 +4,7 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
public enum TRUIdentifier public enum TruIdentifier
{ {
Void = 0x0, Void = 0x0,
Dynamic = 0x1, Dynamic = 0x1,

4
Esiur/Data/Types/ArgumentDef.cs
View File

@@ -12,7 +12,7 @@ public class ArgumentDef
public bool Optional { get; set; } public bool Optional { get; set; }
public TRU Type { get; set; } public Tru Type { get; set; }
public ParameterInfo ParameterInfo { get; set; } public ParameterInfo ParameterInfo { get; set; }
@@ -28,7 +28,7 @@ public class ArgumentDef
var cs = (uint)data[offset++]; var cs = (uint)data[offset++];
var name = data.GetString(offset, cs); var name = data.GetString(offset, cs);
offset += cs; offset += cs;
var (size, type) = TRU.Parse(data, offset); var (size, type) = Tru.Parse(data, offset);
offset += size; offset += size;

6
Esiur/Data/Types/ConstantDef.cs
View File

@@ -13,7 +13,7 @@ public class ConstantDef : MemberDef
public object Value { get; set; } public object Value { get; set; }
public Map<string, string> Annotations { get; set; } public Map<string, string> Annotations { get; set; }
public TRU ValueType { get; set; } public Tru ValueType { get; set; }
public FieldInfo FieldInfo { get; set; } public FieldInfo FieldInfo { get; set; }
@@ -27,7 +27,7 @@ public class ConstantDef : MemberDef
var name = data.GetString(offset + 1, data[offset]); var name = data.GetString(offset + 1, data[offset]);
offset += (uint)data[offset] + 1; offset += (uint)data[offset] + 1;
var (dts, valueType) = TRU.Parse(data, offset); var (dts, valueType) = Tru.Parse(data, offset);
offset += dts; offset += dts;
@@ -100,7 +100,7 @@ public class ConstantDef : MemberDef
{ {
var annotationAttrs = ci.GetCustomAttributes<AnnotationAttribute>(true); var annotationAttrs = ci.GetCustomAttributes<AnnotationAttribute>(true);
var valueType = TRU.FromType(ci.FieldType); var valueType = Tru.FromType(ci.FieldType);
if (valueType == null) if (valueType == null)
throw new Exception($"Unsupported type `{ci.FieldType}` in constant `{type.Name}.{ci.Name}`"); throw new Exception($"Unsupported type `{ci.FieldType}` in constant `{type.Name}.{ci.Name}`");

6
Esiur/Data/Types/EventDef.cs
View File

@@ -29,7 +29,7 @@ public class EventDef : MemberDef
public EventInfo EventInfo { get; set; } public EventInfo EventInfo { get; set; }
public TRU ArgumentType { get; set; } public Tru ArgumentType { get; set; }
public static (uint, EventDef) Parse(byte[] data, uint offset, byte index, bool inherited) public static (uint, EventDef) Parse(byte[] data, uint offset, byte index, bool inherited)
@@ -42,7 +42,7 @@ public class EventDef : MemberDef
var name = data.GetString(offset + 1, data[offset]); var name = data.GetString(offset + 1, data[offset]);
offset += (uint)data[offset] + 1; offset += (uint)data[offset] + 1;
var (dts, argType) = TRU.Parse(data, offset); var (dts, argType) = Tru.Parse(data, offset);
offset += dts; offset += dts;
@@ -116,7 +116,7 @@ public class EventDef : MemberDef
var argType = ei.EventHandlerType.GenericTypeArguments[0]; var argType = ei.EventHandlerType.GenericTypeArguments[0];
var evtType = TRU.FromType(argType); var evtType = Tru.FromType(argType);
if (evtType == null) if (evtType == null)
throw new Exception($"Unsupported type `{argType}` in event `{type.Name}.{ei.Name}`"); throw new Exception($"Unsupported type `{argType}` in event `{type.Name}.{ei.Name}`");

18
Esiur/Data/Types/FunctionDef.cs
View File

@@ -27,7 +27,7 @@ public class FunctionDef : MemberDef
// set; // set;
//} //}
public TRU ReturnType { get; set; } public Tru ReturnType { get; set; }
public bool IsStatic { get; set; } public bool IsStatic { get; set; }
@@ -52,7 +52,7 @@ public class FunctionDef : MemberDef
offset += (uint)data[offset] + 1; offset += (uint)data[offset] + 1;
// return type // return type
var (rts, returnType) = TRU.Parse(data, offset); var (rts, returnType) = Tru.Parse(data, offset);
offset += rts; offset += rts;
// arguments count // arguments count
@@ -124,27 +124,27 @@ public class FunctionDef : MemberDef
var genericRtType = mi.ReturnType.IsGenericType ? mi.ReturnType.GetGenericTypeDefinition() : null; var genericRtType = mi.ReturnType.IsGenericType ? mi.ReturnType.GetGenericTypeDefinition() : null;
TRU rtType; Tru rtType;
if (genericRtType == typeof(AsyncReply<>)) if (genericRtType == typeof(AsyncReply<>))
{ {
rtType = TRU.FromType(mi.ReturnType.GetGenericArguments()[0]); rtType = Tru.FromType(mi.ReturnType.GetGenericArguments()[0]);
} }
else if (genericRtType == typeof(Task<>)) else if (genericRtType == typeof(Task<>))
{ {
rtType = TRU.FromType(mi.ReturnType.GetGenericArguments()[0]); rtType = Tru.FromType(mi.ReturnType.GetGenericArguments()[0]);
} }
else if (genericRtType == typeof(IEnumerable<>) || genericRtType == typeof(IAsyncEnumerable<>)) else if (genericRtType == typeof(IEnumerable<>) || genericRtType == typeof(IAsyncEnumerable<>))
{ {
// get export // get export
rtType = TRU.FromType(mi.ReturnType.GetGenericArguments()[0]); rtType = Tru.FromType(mi.ReturnType.GetGenericArguments()[0]);
} }
else else
{ {
if (mi.ReturnType == typeof(Task)) if (mi.ReturnType == typeof(Task))
rtType = TRU.FromType(null); rtType = Tru.FromType(null);
else else
rtType = TRU.FromType(mi.ReturnType); rtType = Tru.FromType(mi.ReturnType);
} }
if (rtType == null) if (rtType == null)
@@ -214,7 +214,7 @@ public class FunctionDef : MemberDef
var arguments = args.Select(x => var arguments = args.Select(x =>
{ {
var argType = TRU.FromType(x.ParameterType); var argType = Tru.FromType(x.ParameterType);
if (argType == null) if (argType == null)
throw new Exception($"Unsupported type `{x.ParameterType}` in method `{type.Name}.{mi.Name}` parameter `{x.Name}`"); throw new Exception($"Unsupported type `{x.ParameterType}` in method `{type.Name}.{mi.Name}` parameter `{x.Name}`");

8
Esiur/Data/Types/PropertyDef.cs
View File

@@ -24,7 +24,7 @@ public class PropertyDef : MemberDef
set; set;
} }
public TRU ValueType { get; set; } public Tru ValueType { get; set; }
/* /*
@@ -93,7 +93,7 @@ public class PropertyDef : MemberDef
offset += (uint)data[offset] + 1; offset += (uint)data[offset] + 1;
var (dts, valueType) = TRU.Parse(data, offset); var (dts, valueType) = Tru.Parse(data, offset);
offset += dts; offset += dts;
@@ -200,8 +200,8 @@ public class PropertyDef : MemberDef
var genericPropType = pi.PropertyType.IsGenericType ? pi.PropertyType.GetGenericTypeDefinition() : null; var genericPropType = pi.PropertyType.IsGenericType ? pi.PropertyType.GetGenericTypeDefinition() : null;
var propType = genericPropType == typeof(PropertyContext<>) ? var propType = genericPropType == typeof(PropertyContext<>) ?
TRU.FromType(pi.PropertyType.GetGenericArguments()[0]) : Tru.FromType(pi.PropertyType.GetGenericArguments()[0]) :
TRU.FromType(pi.PropertyType); Tru.FromType(pi.PropertyType);
if (propType == null) if (propType == null)
throw new Exception($"Unsupported type `{pi.PropertyType}` in property `{type.Name}.{pi.Name}`"); throw new Exception($"Unsupported type `{pi.PropertyType}` in property `{type.Name}.{pi.Name}`");

12
Esiur/Data/Types/TypeDef.cs
View File

@@ -18,8 +18,8 @@ namespace Esiur.Data.Types;
public class TypeDef public class TypeDef
{ {
protected UUID typeId; protected Uuid typeId;
protected UUID? parentId; protected Uuid? parentId;
public Map<string, string> Annotations { get; set; } public Map<string, string> Annotations { get; set; }
@@ -41,7 +41,7 @@ public class TypeDef
protected byte[] content; protected byte[] content;
public UUID? ParentId => parentId; public Uuid? ParentId => parentId;
public byte[] Content public byte[] Content
{ {
@@ -110,7 +110,7 @@ public class TypeDef
return null; return null;
} }
public UUID Id public Uuid Id
{ {
get { return typeId; } get { return typeId; }
} }
@@ -142,7 +142,7 @@ public class TypeDef
} }
public static UUID GetTypeUUID(Type type) public static Uuid GetTypeUUID(Type type)
{ {
var attr = type.GetCustomAttribute<TypeIdAttribute>(); var attr = type.GetCustomAttribute<TypeIdAttribute>();
if (attr != null) if (attr != null)
@@ -153,7 +153,7 @@ public class TypeDef
hash[6] = (byte)((hash[6] & 0xF) | 0x80); hash[6] = (byte)((hash[6] & 0xF) | 0x80);
hash[8] = (byte)((hash[8] & 0xF) | 0x80); hash[8] = (byte)((hash[8] & 0xF) | 0x80);
var rt = new UUID(hash); var rt = new Uuid(hash);
return rt; return rt;
} }

12
Esiur/Data/UUID.cs
View File

@@ -9,7 +9,7 @@ using System.Text;
namespace Esiur.Data namespace Esiur.Data
{ {
//[StructLayout(LayoutKind.Sequential, Pack = 1)] //[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct UUID public struct Uuid
{ {
//4e7db2d8-a785-1b99-1854-4b4018bc5677 //4e7db2d8-a785-1b99-1854-4b4018bc5677
//byte a1; //byte a1;
@@ -32,7 +32,7 @@ namespace Esiur.Data
public byte[] Data { get; private set; } public byte[] Data { get; private set; }
public UUID(byte[] data, uint offset) public Uuid(byte[] data, uint offset)
{ {
if (offset + 16 > data.Length) if (offset + 16 > data.Length)
throw new Exception("UUID data size must be at least 16 bytes"); throw new Exception("UUID data size must be at least 16 bytes");
@@ -74,7 +74,7 @@ namespace Esiur.Data
} }
public UUID(byte[] data) { public Uuid(byte[] data) {
if (data.Length != 16) if (data.Length != 16)
throw new Exception("UUID data size must be 16 bytes"); throw new Exception("UUID data size must be 16 bytes");
@@ -107,13 +107,13 @@ namespace Esiur.Data
public override bool Equals(object obj) public override bool Equals(object obj)
{ {
if (obj is UUID b) if (obj is Uuid b)
return Data.SequenceEqual(b.Data); return Data.SequenceEqual(b.Data);
return false; return false;
} }
public static bool operator == (UUID a, UUID b) public static bool operator == (Uuid a, Uuid b)
{ {
return a.Data.SequenceEqual(b.Data); return a.Data.SequenceEqual(b.Data);
@@ -135,7 +135,7 @@ namespace Esiur.Data
// && a.e6 == b.e6; // && a.e6 == b.e6;
} }
public static bool operator !=(UUID a, UUID b) public static bool operator !=(Uuid a, Uuid b)
{ {
return !(a == b); return !(a == b);
} }

9
Esiur/Esiur.csproj
View File

@@ -39,6 +39,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="BouncyCastle.Cryptography" Version="2.6.2" />
<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.2" /> <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.2" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" PrivateAssets="all" /> <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" PrivateAssets="all" />
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="4.14.0" PrivateAssets="all" /> <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="4.14.0" PrivateAssets="all" />
@@ -60,6 +61,10 @@
<ItemGroup> <ItemGroup>
<Compile Remove="Data\NullabilityInfo.cs" /> <Compile Remove="Data\NullabilityInfo.cs" />
<Compile Remove="Data\NullabilityInfoContext.cs" /> <Compile Remove="Data\NullabilityInfoContext.cs" />
<Compile Remove="Net\Packets\EpAuthPacketAuthMode.cs" />
<Compile Remove="Security\Authority\AuthenticationMethod.cs" />
<Compile Remove="Security\Authority\IAuthenticationInitiator.cs" />
<Compile Remove="Security\Authority\IAuthenticationResponder.cs" />
</ItemGroup> </ItemGroup>
@@ -69,7 +74,11 @@
<None Include="Data\Types\ArgumentDef.cs" /> <None Include="Data\Types\ArgumentDef.cs" />
<None Include="Data\Types\AttributeDef.cs" /> <None Include="Data\Types\AttributeDef.cs" />
<None Include="LICENSE" Pack="true" PackagePath=""></None> <None Include="LICENSE" Pack="true" PackagePath=""></None>
<None Include="Net\Packets\EpAuthPacketAuthMode.cs" />
<None Include="README.md" Pack="true" PackagePath="" /> <None Include="README.md" Pack="true" PackagePath="" />
<None Include="Security\Authority\AuthenticationMethod.cs" />
<None Include="Security\Authority\IAuthenticationInitiator.cs" />
<None Include="Security\Authority\IAuthenticationResponder.cs" />
</ItemGroup> </ItemGroup>

42
Esiur/Net/HTTP/HTTPConnection.cs
View File

@@ -37,22 +37,22 @@ using Esiur.Misc;
using System.Security.Cryptography; using System.Security.Cryptography;
using Esiur.Core; using Esiur.Core;
using Esiur.Net.Packets.WebSocket; using Esiur.Net.Packets.WebSocket;
using Esiur.Net.Packets.HTTP; using Esiur.Net.Packets.Http;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public class HTTPConnection : NetworkConnection public class HttpConnection : NetworkConnection
{ {
public bool WSMode { get; internal set; } public bool WSMode { get; internal set; }
public HTTPServer Server { get; internal set; } public HttpServer Server { get; internal set; }
public WebsocketPacket WSRequest { get; set; } public WebsocketPacket WSRequest { get; set; }
public HTTPRequestPacket Request { get; set; } public HttpRequestPacket Request { get; set; }
public HTTPResponsePacket Response { get; } = new HTTPResponsePacket(); public HttpResponsePacket Response { get; } = new HttpResponsePacket();
HTTPSession session; HttpSession session;
public KeyList<string, object> Variables { get; } = new KeyList<string, object>(); public KeyList<string, object> Variables { get; } = new KeyList<string, object>();
@@ -80,7 +80,7 @@ public class HTTPConnection : NetworkConnection
} }
else else
{ {
var rp = new HTTPRequestPacket(); var rp = new HttpRequestPacket();
var pSize = rp.Parse(data, 0, (uint)data.Length); var pSize = rp.Parse(data, 0, (uint)data.Length);
if (pSize > 0) if (pSize > 0)
{ {
@@ -115,7 +115,7 @@ public class HTTPConnection : NetworkConnection
return ok; return ok;
} }
public static bool Upgrade(HTTPRequestPacket request, HTTPResponsePacket response) public static bool Upgrade(HttpRequestPacket request, HttpResponsePacket response)
{ {
if (IsWebsocketRequest(request)) if (IsWebsocketRequest(request))
{ {
@@ -132,7 +132,7 @@ public class HTTPConnection : NetworkConnection
response.Headers["Sec-WebSocket-Protocol"] = request.Headers["Sec-WebSocket-Protocol"]; response.Headers["Sec-WebSocket-Protocol"] = request.Headers["Sec-WebSocket-Protocol"];
response.Number = HTTPResponseCode.Switching; response.Number = HttpResponseCode.Switching;
response.Text = "Switching Protocols"; response.Text = "Switching Protocols";
return true; return true;
@@ -141,7 +141,7 @@ public class HTTPConnection : NetworkConnection
return false; return false;
} }
public HTTPServer Parent public HttpServer Parent
{ {
get get
{ {
@@ -173,7 +173,7 @@ public class HTTPConnection : NetworkConnection
Send(); Send();
} }
public void Send(HTTPComposeOption Options = HTTPComposeOption.AllCalculateLength) public void Send(HttpComposeOption Options = HttpComposeOption.AllCalculateLength)
{ {
if (Response.Handled) if (Response.Handled)
return; return;
@@ -211,7 +211,7 @@ public class HTTPConnection : NetworkConnection
// Create a new one // Create a new one
session = Server.CreateSession(Global.GenerateCode(12), 60 * 20); session = Server.CreateSession(Global.GenerateCode(12), 60 * 20);
HTTPCookie cookie = new HTTPCookie("SID", session.Id); HttpCookie cookie = new HttpCookie("SID", session.Id);
cookie.Expires = DateTime.MaxValue; cookie.Expires = DateTime.MaxValue;
cookie.Path = "/"; cookie.Path = "/";
cookie.HttpOnly = true; cookie.HttpOnly = true;
@@ -226,7 +226,7 @@ public class HTTPConnection : NetworkConnection
return IsWebsocketRequest(this.Request); return IsWebsocketRequest(this.Request);
} }
public static bool IsWebsocketRequest(HTTPRequestPacket request) public static bool IsWebsocketRequest(HttpRequestPacket request)
{ {
if (request.Headers.ContainsKey("connection") if (request.Headers.ContainsKey("connection")
&& request.Headers["connection"].ToLower().Contains("upgrade") && request.Headers["connection"].ToLower().Contains("upgrade")
@@ -254,7 +254,7 @@ public class HTTPConnection : NetworkConnection
if (BL == 0) if (BL == 0)
{ {
if (Request.Method == HTTPMethod.UNKNOWN) if (Request.Method == Packets.Http.HttpMethod.UNKNOWN)
{ {
Close(); Close();
return; return;
@@ -313,7 +313,7 @@ public class HTTPConnection : NetworkConnection
{ {
if (!Server.Execute(this)) if (!Server.Execute(this))
{ {
Response.Number = HTTPResponseCode.InternalServerError; Response.Number = HttpResponseCode.InternalServerError;
Send("Bad Request"); Send("Bad Request");
Close(); Close();
} }
@@ -362,7 +362,7 @@ public class HTTPConnection : NetworkConnection
if (!File.Exists(filename)) if (!File.Exists(filename))
{ {
Response.Number = HTTPResponseCode.NotFound; Response.Number = HttpResponseCode.NotFound;
Send("File Not Found"); Send("File Not Found");
return true; return true;
} }
@@ -376,10 +376,10 @@ public class HTTPConnection : NetworkConnection
var ims = DateTime.Parse(Request.Headers["if-modified-since"]); var ims = DateTime.Parse(Request.Headers["if-modified-since"]);
if ((fileEditTime - ims).TotalSeconds < 2) if ((fileEditTime - ims).TotalSeconds < 2)
{ {
Response.Number = HTTPResponseCode.NotModified; Response.Number = HttpResponseCode.NotModified;
Response.Headers.Clear(); Response.Headers.Clear();
//Response.Text = "Not Modified"; //Response.Text = "Not Modified";
Send(HTTPComposeOption.SpecifiedHeadersOnly); Send(HttpComposeOption.SpecifiedHeadersOnly);
return true; return true;
} }
} }
@@ -391,12 +391,12 @@ public class HTTPConnection : NetworkConnection
Response.Number = HTTPResponseCode.OK; Response.Number = HttpResponseCode.OK;
// Fri, 30 Oct 2007 14:19:41 GMT // Fri, 30 Oct 2007 14:19:41 GMT
Response.Headers["Last-Modified"] = fileEditTime.ToString("ddd, dd MMM yyyy HH:mm:ss"); Response.Headers["Last-Modified"] = fileEditTime.ToString("ddd, dd MMM yyyy HH:mm:ss");
FileInfo fi = new FileInfo(filename); FileInfo fi = new FileInfo(filename);
Response.Headers["Content-Length"] = fi.Length.ToString(); Response.Headers["Content-Length"] = fi.Length.ToString();
Send(HTTPComposeOption.SpecifiedHeadersOnly); Send(HttpComposeOption.SpecifiedHeadersOnly);
//var fd = File.ReadAllBytes(filename); //var fd = File.ReadAllBytes(filename);

10
Esiur/Net/HTTP/HTTPFilter.cs
View File

@@ -35,9 +35,9 @@ using Esiur.Data;
using Esiur.Core; using Esiur.Core;
using Esiur.Resource; using Esiur.Resource;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public abstract class HTTPFilter : IResource public abstract class HttpFilter : IResource
{ {
public Instance Instance public Instance Instance
{ {
@@ -60,14 +60,14 @@ public abstract class HTTPFilter : IResource
} }
*/ */
public abstract AsyncReply<bool> Execute(HTTPConnection sender); public abstract AsyncReply<bool> Execute(HttpConnection sender);
public virtual void ClientConnected(HTTPConnection HTTP) public virtual void ClientConnected(HttpConnection HTTP)
{ {
//return false; //return false;
} }
public virtual void ClientDisconnected(HTTPConnection HTTP) public virtual void ClientDisconnected(HttpConnection HTTP)
{ {
//return false; //return false;
} }

54
Esiur/Net/HTTP/HTTPServer.cs
View File

@@ -40,25 +40,25 @@ using Esiur.Resource;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
using Esiur.Net.Packets.HTTP; using Esiur.Net.Packets.Http;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public class HTTPServer : NetworkServer<HTTPConnection>, IResource public class HttpServer : NetworkServer<HttpConnection>, IResource
{ {
Dictionary<string, HTTPSession> sessions = new Dictionary<string, HTTPSession>(); Dictionary<string, HttpSession> sessions = new Dictionary<string, HttpSession>();
HTTPFilter[] filters = new HTTPFilter[0]; HttpFilter[] filters = new HttpFilter[0];
Dictionary<HTTPMethod, List<RouteInfo>> routes = new() Dictionary<Packets.Http.HttpMethod, List<RouteInfo>> routes = new()
{ {
[HTTPMethod.GET] = new List<RouteInfo>(), [Packets.Http.HttpMethod.GET] = new List<RouteInfo>(),
[HTTPMethod.POST] = new List<RouteInfo>(), [Packets.Http.HttpMethod.POST] = new List<RouteInfo>(),
[HTTPMethod.HEAD] = new List<RouteInfo>(), [Packets.Http.HttpMethod.HEAD] = new List<RouteInfo>(),
[HTTPMethod.OPTIONS] = new List<RouteInfo>(), [Packets.Http.HttpMethod.OPTIONS] = new List<RouteInfo>(),
[HTTPMethod.UNKNOWN] = new List<RouteInfo>(), [Packets.Http.HttpMethod.UNKNOWN] = new List<RouteInfo>(),
[HTTPMethod.DELETE] = new List<RouteInfo>(), [Packets.Http.HttpMethod.DELETE] = new List<RouteInfo>(),
[HTTPMethod.TRACE] = new List<RouteInfo>(), [Packets.Http.HttpMethod.TRACE] = new List<RouteInfo>(),
[HTTPMethod.CONNECT] = new List<RouteInfo>(), [Packets.Http.HttpMethod.CONNECT] = new List<RouteInfo>(),
[HTTPMethod.PUT] = new List<RouteInfo>() [Packets.Http.HttpMethod.PUT] = new List<RouteInfo>()
}; };
//List<RouteInfo> GetRoutes = new List<RouteInfo>(); //List<RouteInfo> GetRoutes = new List<RouteInfo>();
@@ -86,7 +86,7 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
var last = ps.LastOrDefault(); var last = ps.LastOrDefault();
if (last != null && last.ParameterType == typeof(HTTPConnection)) if (last != null && last.ParameterType == typeof(HttpConnection))
{ {
SenderIndex = ps.Length - 1; SenderIndex = ps.Length - 1;
@@ -101,7 +101,7 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
} }
public bool Invoke(HTTPConnection sender) public bool Invoke(HttpConnection sender)
{ {
var match = Pattern.Match(sender.Request.URL); var match = Pattern.Match(sender.Request.URL);
@@ -176,9 +176,9 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
} }
public HTTPSession CreateSession(string id, int timeout) public HttpSession CreateSession(string id, int timeout)
{ {
var s = new HTTPSession(); var s = new HttpSession();
s.Set(id, timeout); s.Set(id, timeout);
@@ -214,7 +214,7 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
return Cookie; return Cookie;
} }
protected override void ClientDisconnected(HTTPConnection connection) protected override void ClientDisconnected(HttpConnection connection)
{ {
foreach (var filter in filters) foreach (var filter in filters)
filter.ClientDisconnected(connection); filter.ClientDisconnected(connection);
@@ -222,7 +222,7 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
internal bool Execute(HTTPConnection sender) internal bool Execute(HttpConnection sender)
{ {
if (!sender.WSMode) if (!sender.WSMode)
foreach (var route in routes[sender.Request.Method]) foreach (var route in routes[sender.Request.Method])
@@ -243,14 +243,14 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
public void MapGet(string pattern, Delegate handler) public void MapGet(string pattern, Delegate handler)
{ {
var regex = Global.GetRouteRegex(pattern); var regex = Global.GetRouteRegex(pattern);
var list = routes[HTTPMethod.GET]; var list = routes[Packets.Http.HttpMethod.GET];
list.Add(new RouteInfo(handler, regex)); list.Add(new RouteInfo(handler, regex));
} }
public void MapPost(string pattern, Delegate handler) public void MapPost(string pattern, Delegate handler)
{ {
var regex = Global.GetRouteRegex(pattern); var regex = Global.GetRouteRegex(pattern);
var list = routes[HTTPMethod.POST]; var list = routes[Packets.Http.HttpMethod.POST];
list.Add(new RouteInfo(handler, regex)); list.Add(new RouteInfo(handler, regex));
} }
@@ -329,7 +329,7 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
} }
else if (trigger == ResourceTrigger.SystemInitialized) else if (trigger == ResourceTrigger.SystemInitialized)
{ {
filters = await Instance.Children<HTTPFilter>(); filters = await Instance.Children<HttpFilter>();
} }
return true; return true;
@@ -337,19 +337,19 @@ public class HTTPServer : NetworkServer<HTTPConnection>, IResource
} }
public override void Add(HTTPConnection connection) public override void Add(HttpConnection connection)
{ {
connection.Server = this; connection.Server = this;
base.Add(connection); base.Add(connection);
} }
public override void Remove(HTTPConnection connection) public override void Remove(HttpConnection connection)
{ {
connection.Server = null; connection.Server = null;
base.Remove(connection); base.Remove(connection);
} }
protected override void ClientConnected(HTTPConnection connection) protected override void ClientConnected(HttpConnection connection)
{ {
//if (filters.Length == 0 && routes.) //if (filters.Length == 0 && routes.)
//{ //{

10
Esiur/Net/HTTP/HTTPSession.cs
View File

@@ -35,11 +35,11 @@ using Esiur.Data;
using Esiur.Misc; using Esiur.Misc;
using Esiur.Core; using Esiur.Core;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public class HTTPSession : IDestructible //<T> where T : TClient public class HttpSession : IDestructible //<T> where T : TClient
{ {
public delegate void SessionModifiedEvent(HTTPSession session, string key, object oldValue, object newValue); public delegate void SessionModifiedEvent(HttpSession session, string key, object oldValue, object newValue);
public delegate void SessionEndedEvent(HTTPSession session); public delegate void SessionEndedEvent(HttpSession session);
private string id; private string id;
private Timer timer; private Timer timer;
@@ -58,7 +58,7 @@ public class HTTPSession : IDestructible //<T> where T : TClient
get { return variables; } get { return variables; }
} }
public HTTPSession() public HttpSession()
{ {
variables = new KeyList<string, object>(); variables = new KeyList<string, object>();
variables.OnModified += new KeyList<string, object>.Modified(VariablesModified); variables.OnModified += new KeyList<string, object>.Modified(VariablesModified);

6
Esiur/Net/Http/EPoHTTP.cs → Esiur/Net/Http/EpOverHttp.cs
View File

@@ -6,13 +6,13 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public class EPoHTTP : HTTPFilter public class EpOverHttp : HttpFilter
{ {
[Attribute] [Attribute]
EntryPoint EntryPoint { get; set; } EntryPoint EntryPoint { get; set; }
public override AsyncReply<bool> Execute(HTTPConnection sender) public override AsyncReply<bool> Execute(HttpConnection sender)
{ {
if (sender.Request.URL != "EP") if (sender.Request.URL != "EP")
return new AsyncReply<bool>(false); return new AsyncReply<bool>(false);

6
Esiur/Net/Http/EPoWS.cs → Esiur/Net/Http/EpOvwerWebsocket.cs
View File

@@ -32,8 +32,8 @@ using Esiur.Net.Sockets;
using Esiur.Core; using Esiur.Core;
using Esiur.Protocol; using Esiur.Protocol;
namespace Esiur.Net.HTTP; namespace Esiur.Net.Http;
public class EPoWS : HTTPFilter public class EpOvwerWebsocket : HttpFilter
{ {
[Attribute] [Attribute]
public EpServer Server public EpServer Server
@@ -42,7 +42,7 @@ public class EPoWS : HTTPFilter
set; set;
} }
public override AsyncReply<bool> Execute(HTTPConnection sender) public override AsyncReply<bool> Execute(HttpConnection sender)
{ {
if (sender.IsWebsocketRequest()) if (sender.IsWebsocketRequest())

362
Esiur/Net/Packets/EpAuthPacket.cs
View File

@@ -1,6 +1,6 @@
/* /*
Copyright (c) 2017 Ahmed Kh. Zamil Copyright (c) 2017-2026 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
@@ -37,23 +37,11 @@ namespace Esiur.Net.Packets;
public class EpAuthPacket : Packet public class EpAuthPacket : Packet
{ {
public EpAuthPacketCommand Command public EpAuthPacketCommand Command
{ {
get; get;
set; set;
} }
public EpAuthPacketInitialize Initialization
{
get;
set;
}
public EpAuthPacketAcknowledge Acknowledgement
{
get;
set;
}
public EpAuthPacketAction Action public EpAuthPacketAction Action
{ {
@@ -67,18 +55,32 @@ public class EpAuthPacket : Packet
set; set;
} }
public AuthenticationMethod LocalMethod public EpAuthPacketAcknowledgement Acknowledgement
{ {
get; get;
set; set;
} }
public AuthenticationMethod RemoteMethod
public EpAuthPacketAuthMode AuthMode
{ {
get; get;
set; set;
} }
public EpAuthPacketEncryptionMode EncryptionMode
{
get;
set;
}
//public AuthenticationMethod AuthenticationMethod
//{
// get;
// set;
//}
public byte ErrorCode public byte ErrorCode
{ {
get; get;
@@ -91,52 +93,14 @@ public class EpAuthPacket : Packet
set; set;
} }
public EpAuthPacketPublicKeyAlgorithm PublicKeyAlgorithm
{
get;
set;
}
public EpAuthPacketHashAlgorithm HashAlgorithm
{
get;
set;
}
public byte[] Certificate
{
get;
set;
}
public byte[] Challenge
{
get;
set;
}
public byte[] AsymetricEncryptionKey
{
get;
set;
}
public byte[] SessionId public byte[] SessionId
{ {
get; get;
set; set;
} }
public byte[] AccountId
{
get;
set;
}
public ParsedTDU? DataType public ParsedTdu? Tdu
{ {
get; get;
set; set;
@@ -177,284 +141,46 @@ public class EpAuthPacket : Packet
return -dataLengthNeeded; return -dataLengthNeeded;
Command = (EpAuthPacketCommand)(data[offset] >> 6); Command = (EpAuthPacketCommand)(data[offset] >> 6);
var hasTdu = (data[offset] & 0x20) != 0;
if (Command == EpAuthPacketCommand.Initialize) if (Command == EpAuthPacketCommand.Initialize)
{ {
LocalMethod = (AuthenticationMethod)(data[offset] >> 4 & 0x3); AuthMode = (EpAuthPacketAuthMode)(data[offset] >> 3 & 0x7);
RemoteMethod = (AuthenticationMethod)(data[offset] >> 2 & 0x3); EncryptionMode = (EpAuthPacketEncryptionMode)(data[offset++] & 0x7);
Initialization = (EpAuthPacketInitialize)(data[offset++] & 0xFC); // remove last two reserved LSBs
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
DataType = ParsedTDU.Parse(data, offset, ends);
if (DataType.Value.Class == TDUClass.Invalid)
return -(int)DataType.Value.TotalLength;
offset += (uint)DataType.Value.TotalLength;
} }
else if (Command == EpAuthPacketCommand.Acknowledge) else if (Command == EpAuthPacketCommand.Acknowledge)
{ {
// remove last two reserved LSBs
LocalMethod = (AuthenticationMethod)(data[offset] >> 4 & 0x3); Acknowledgement = (EpAuthPacketAcknowledgement)(data[offset++]);// & 0xFC);
RemoteMethod = (AuthenticationMethod)(data[offset] >> 2 & 0x3);
Acknowledgement = (EpAuthPacketAcknowledge)(data[offset++] & 0xFC); // remove last two reserved LSBs
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
DataType = ParsedTDU.Parse(data, offset, ends);
if (DataType.Value.Class == TDUClass.Invalid)
return -(int)DataType.Value.TotalLength;
offset += (uint)DataType.Value.TotalLength;
} }
else if (Command == EpAuthPacketCommand.Action) else if (Command == EpAuthPacketCommand.Action)
{ {
Action = (EpAuthPacketAction)data[offset++]; // (EPAuthPacketAction)(data[offset++] & 0x3f); // remove last two reserved LSBs
Action = (EpAuthPacketAction)(data[offset++]);// & 0xFC);
if (Action == EpAuthPacketAction.AuthenticateHash
|| Action == EpAuthPacketAction.AuthenticatePublicHash
|| Action == EpAuthPacketAction.AuthenticatePrivateHash
|| Action == EpAuthPacketAction.AuthenticatePublicPrivateHash)
{
if (NotEnough(offset, ends, 3))
return -dataLengthNeeded;
HashAlgorithm = (EpAuthPacketHashAlgorithm)data[offset++];
var hashLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, hashLength))
return -dataLengthNeeded;
Challenge = data.Clip(offset, hashLength);
offset += hashLength;
}
else if (Action == EpAuthPacketAction.AuthenticatePrivateHashCert
|| Action == EpAuthPacketAction.AuthenticatePublicPrivateHashCert)
{
if (NotEnough(offset, ends, 3))
return -dataLengthNeeded;
HashAlgorithm = (EpAuthPacketHashAlgorithm)data[offset++];
var hashLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, hashLength))
return -dataLengthNeeded;
Challenge = data.Clip(offset, hashLength);
offset += hashLength;
if (NotEnough(offset, ends, 2))
return -dataLengthNeeded;
var certLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, certLength))
return -dataLengthNeeded;
Certificate = data.Clip(offset, certLength);
offset += certLength;
}
else if (Action == EpAuthPacketAction.IAuthPlain)
{
if (NotEnough(offset, ends, 5))
return -dataLengthNeeded;
Reference = data.GetUInt32(offset, Endian.Little);
offset += 4;
DataType = ParsedTDU.Parse(data, offset, ends);
if (DataType.Value.Class == TDUClass.Invalid)
return -(int)DataType.Value.TotalLength;
offset += (uint)DataType.Value.TotalLength;
}
else if (Action == EpAuthPacketAction.IAuthHashed)
{
if (NotEnough(offset, ends, 7))
return -dataLengthNeeded;
Reference = data.GetUInt32(offset, Endian.Little);
offset += 4;
HashAlgorithm = (EpAuthPacketHashAlgorithm)data[offset++];
var cl = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, cl))
return -dataLengthNeeded;
Challenge = data.Clip(offset, cl);
offset += cl;
}
else if (Action == EpAuthPacketAction.IAuthEncrypted)
{
if (NotEnough(offset, ends, 7))
return -dataLengthNeeded;
Reference = data.GetUInt32(offset, Endian.Little);
offset += 4;
PublicKeyAlgorithm = (EpAuthPacketPublicKeyAlgorithm)data[offset++];
var cl = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, cl))
return -dataLengthNeeded;
Challenge = data.Clip(offset, cl);
offset += cl;
}
else if (Action == EpAuthPacketAction.EstablishNewSession)
{
// Nothing here
}
else if (Action == EpAuthPacketAction.EstablishResumeSession)
{
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
var sessionLength = data[offset++];
if (NotEnough(offset, ends, sessionLength))
return -dataLengthNeeded;
SessionId = data.Clip(offset, sessionLength);
offset += sessionLength;
}
else if (Action == EpAuthPacketAction.EncryptKeyExchange)
{
if (NotEnough(offset, ends, 2))
return -dataLengthNeeded;
var keyLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, keyLength))
return -dataLengthNeeded;
AsymetricEncryptionKey = data.Clip(offset, keyLength);
offset += keyLength;
}
else if (Action == EpAuthPacketAction.RegisterEndToEndKey
|| Action == EpAuthPacketAction.RegisterHomomorphic)
{
if (NotEnough(offset, ends, 3))
return -dataLengthNeeded;
PublicKeyAlgorithm = (EpAuthPacketPublicKeyAlgorithm)data[offset++];
var keyLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, keyLength))
return -dataLengthNeeded;
AsymetricEncryptionKey = data.Clip(offset, keyLength);
offset += keyLength;
}
} }
else if (Command == EpAuthPacketCommand.Event) else if (Command == EpAuthPacketCommand.Event)
{ {
// remove last two reserved LSBs
Event = (EpAuthPacketEvent)data[offset++]; Event = (EpAuthPacketEvent)(data[offset++]);// & 0xFC);
}
if (Event == EpAuthPacketEvent.ErrorTerminate else
|| Event == EpAuthPacketEvent.ErrorMustEncrypt {
|| Event == EpAuthPacketEvent.ErrorRetry) return -1; // invalid command
{
if (NotEnough(offset, ends, 3))
return -dataLengthNeeded;
ErrorCode = data[offset++];
var msgLength = data.GetUInt16(offset, Endian.Little);
offset += 2;
if (NotEnough(offset, ends, msgLength))
return -dataLengthNeeded;
Message = data.GetString(offset, msgLength);
offset += msgLength;
}
else if (Event == EpAuthPacketEvent.IndicationEstablished)
{
if (NotEnough(offset, ends, 2))
return -dataLengthNeeded;
var sessionLength = data[offset++];
if (NotEnough(offset, ends, sessionLength))
return -dataLengthNeeded;
SessionId = data.Clip(offset, sessionLength);
offset += sessionLength;
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
var accountLength = data[offset++];
if (NotEnough(offset, ends, accountLength))
return -dataLengthNeeded;
AccountId = data.Clip(offset, accountLength);
offset += accountLength;
}
else if (Event == EpAuthPacketEvent.IAuthPlain
|| Event == EpAuthPacketEvent.IAuthHashed
|| Event == EpAuthPacketEvent.IAuthEncrypted)
{
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
DataType = ParsedTDU.Parse(data, offset, ends);
if (DataType.Value.Class == TDUClass.Invalid)
return -(int)DataType.Value.TotalLength;
offset += (uint)DataType.Value.TotalLength;
}
} }
if (hasTdu)
{
if (NotEnough(offset, ends, 1))
return -dataLengthNeeded;
Tdu = ParsedTdu.Parse(data, offset, ends);
if (Tdu.Value.Class == TduClass.Invalid)
return -(int)Tdu.Value.TotalLength;
offset += (uint)Tdu.Value.TotalLength;
}
return offset - oOffset; return offset - oOffset;

26
Esiur/Net/Packets/EpAuthPacketAcknowledge.cs
View File

@@ -1,26 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketAcknowledge : byte
{
NoAuthNoAuth = 0x40, // 0b01000000,
NoAuthCredentials = 0x44, // 0b01000100,
NoAuthToken = 0x48, //0b01001000,
NoAuthCertificate = 0x4c, //0b01001100,
CredentialsNoAuth = 0x50, //0b01010000,
CredentialsCredentials = 0x54, //0b01010100,
CredentialsToken = 0x58, //0b01011000,
CredentialsCertificate = 0x5c, //0b01011100,
TokenNoAuth = 0x60, //0b01100000,
TokenCredentials = 0x64, //0b01100100,
TokenToken = 0x68, //0b01101000,
TokenCertificate = 0x6c, //0b01101100,
CertificateNoAuth = 0x70, //0b01110000,
CertificateCredentials = 0x74, //0b01110100,
CertificateToken = 0x78, //0b01111000,
CertificateCertificate = 0x7c, // 0b01111100,
}
}

18
Esiur/Net/Packets/EpAuthPacketAcknowledgement.cs Normal file
View File

@@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketAcknowledgement : byte
{
Denied = 0x40, // no reason, terminate connection
NotSupported = 0x41, // auth not supported, terminate connection
TrySupported = 0x42, // auth not supported, but other auth methods in the reply are supported. connection is still open
Retry = 0x43, // try another auth method, connection is still open
ProceedToHandshake = 0x44, // auth method accepted, proceed to handshake, connection is still open
ProceedToFinalHandshake = 0x45, // auth method accepted, proceed to final handshake, connection is still open
ProceedToEstablishSession = 0x46, // auth method accepted, proceed to establish session, connection is still open
SessionEstablished = 0x47, // session established, session Id provided, switch to session mode, connection is still open
}
}

31
Esiur/Net/Packets/EpAuthPacketAction.cs
View File

@@ -6,26 +6,29 @@ namespace Esiur.Net.Packets
{ {
public enum EpAuthPacketAction : byte public enum EpAuthPacketAction : byte
{ {
AuthenticateHash = 0x80, Handshake = 0x80,
AuthenticatePublicHash = 0x81, FinalHandshake = 0x81,
AuthenticatePrivateHash = 0x82,
AuthenticatePublicPrivateHash = 0x83,
AuthenticatePrivateHashCert = 0x88, //AuthenticateHash = 0x80,
AuthenticatePublicPrivateHashCert = 0x89, //AuthenticatePublicHash = 0x81,
//AuthenticatePrivateHash = 0x82,
//AuthenticatePublicPrivateHash = 0x83,
IAuthPlain = 0x90, //AuthenticatePrivateHashCert = 0x88,
IAuthHashed = 0x91, //AuthenticatePublicPrivateHashCert = 0x89,
IAuthEncrypted = 0x92,
//IAuthPlain = 0x90,
//IAuthHashed = 0x91,
//IAuthEncrypted = 0x92,
EstablishNewSession = 0x98, //EstablishNewSession = 0x98,
EstablishResumeSession = 0x99, //EstablishResumeSession = 0x99,
EncryptKeyExchange = 0xA0, //EncryptKeyExchange = 0xA0,
RegisterEndToEndKey = 0xA8, //RegisterEndToEndKey = 0xA8,
RegisterHomomorphic = 0xA9, //RegisterHomomorphic = 0xA9,
} }
} }

32
Esiur/Net/Packets/EpAuthPacketAuthMode.cs Normal file
View File

@@ -0,0 +1,32 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketAuthMode : byte
{
NoAuh = 0x0,
InitializerIdentity = 0x1,
ResponderIdentity = 0x2,
DualIdentity = 0x3,
//NoAuthNoAuth = 0x0, //0b00000000,
//NoAuthCredentials = 0x4, //0b00000100,
//NoAuthToken = 0x8, //0b00001000,
//NoAuthCertificate = 0xC, //0b00001100,
//CredentialsNoAuth = 0x10, //0b00010000,
//CredentialsCredentials = 0x14, //0b00010100,
//CredentialsToken = 0x18, //0b00011000,
//CredentialsCertificate = 0x1c, //0b00011100,
//TokenNoAuth = 0x20, //0b00100000,
//TokenCredentials = 0x24, //0b00100100,
//TokenToken = 0x28, //0b00101000,
//TokenCertificate = 0x2c, //0b00101100,
//CertificateNoAuth = 0x30, //0b00110000,
//CertificateCredentials = 0x34,// 0b00110100,
//CertificateToken = 0x38, //0b00111000,
//CertificateCertificate = 0x3c, //0b00111100,
}
}

1
Esiur/Net/Packets/EpAuthPacketCommand.cs
View File

@@ -11,5 +11,4 @@ namespace Esiur.Net.Packets
Action = 0x2, Action = 0x2,
Event = 0x3, Event = 0x3,
} }
} }

13
Esiur/Net/Packets/EpAuthPacketEncryptionMode.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketEncryptionMode
{
NoEncryption,
EncryptWithSessionKey,
EncryptWithSessionKeyAndAddress,
}
}

12
Esiur/Net/Packets/EpAuthPacketHashAlgorithm.cs
View File

@@ -1,12 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketHashAlgorithm
{
SHA256,
SHA3,
}
}

33
Esiur/Net/Packets/EpAuthPacketHeader.cs
View File

@@ -6,24 +6,19 @@ namespace Esiur.Net.Packets
{ {
public enum EpAuthPacketHeader public enum EpAuthPacketHeader
{ {
Version = 0, Version,
Domain = 1, Domain,
SupportedAuthentications = 2, SupportedAuthentications ,
SupportedHashAlgorithms = 3, SupportedHashAlgorithms,
SupportedCiphers = 4, SupportedCiphers,
SupportedCompression = 5, SupportedCompression,
SupportedPersonalAuth = 6, SupportedMultiFactorAuthentications,
Nonce = 7, CipherType,
Username = 8, CipherKey,
TokenIndex = 9, SoftwareIdentity,
CertificateId = 10, Referrer,
CachedCertificates = 11, Time,
CipherType = 12, IPAddress,
CipherKey = 13, AuthenticationData,
SoftwareIdentity = 14,
Referrer = 15,
Time = 16,
Certificate = 17,
IPAddress = 18,
} }
} }

26
Esiur/Net/Packets/EpAuthPacketInitialize.cs
View File

@@ -1,26 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketInitialize
{
NoAuthNoAuth = 0x0, //0b00000000,
NoAuthCredentials = 0x4, //0b00000100,
NoAuthToken = 0x8, //0b00001000,
NoAuthCertificate = 0xC, //0b00001100,
CredentialsNoAuth = 0x10, //0b00010000,
CredentialsCredentials = 0x14, //0b00010100,
CredentialsToken = 0x18, //0b00011000,
CredentialsCertificate = 0x1c, //0b00011100,
TokenNoAuth = 0x20, //0b00100000,
TokenCredentials = 0x24, //0b00100100,
TokenToken = 0x28, //0b00101000,
TokenCertificate = 0x2c, //0b00101100,
CertificateNoAuth = 0x30, //0b00110000,
CertificateCredentials = 0x34,// 0b00110100,
CertificateToken = 0x38, //0b00111000,
CertificateCertificate = 0x3c, //0b00111100,
}
}

12
Esiur/Net/Packets/EpAuthPacketPublicKeyAlgorithm.cs
View File

@@ -1,12 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Packets
{
public enum EpAuthPacketPublicKeyAlgorithm
{
RSA = 0,
CKKS = 1,
}
}

14
Esiur/Net/Packets/EpPacket.cs
View File

@@ -1,6 +1,6 @@
/* /*
Copyright (c) 2017-2025 Ahmed Kh. Zamil Copyright (c) 2017-2026 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
@@ -44,7 +44,7 @@ class EpPacket : Packet
public byte Extension { get; set; } public byte Extension { get; set; }
public ParsedTDU? DataType { get; set; } public ParsedTdu? Tdu { get; set; }
private uint dataLengthNeeded; private uint dataLengthNeeded;
@@ -124,16 +124,16 @@ class EpPacket : Packet
if (NotEnough(offset, ends, 1)) if (NotEnough(offset, ends, 1))
return -dataLengthNeeded; return -dataLengthNeeded;
DataType = ParsedTDU.Parse(data, offset, ends); Tdu = ParsedTdu.Parse(data, offset, ends);
if (DataType.Value.Class == TDUClass.Invalid) if (Tdu.Value.Class == TduClass.Invalid)
return -(int)DataType.Value.TotalLength; return -(int)Tdu.Value.TotalLength;
offset += (uint)DataType.Value.TotalLength; offset += (uint)Tdu.Value.TotalLength;
} }
else else
{ {
DataType = null; Tdu = null;
} }
return offset - originalOffset; return offset - originalOffset;

4
Esiur/Net/Packets/EpPacketAttachInfo.cs
View File

@@ -10,9 +10,9 @@ struct EpPacketAttachInfo
public string Link; public string Link;
public ulong Age; public ulong Age;
public byte[] Content; public byte[] Content;
public UUID TypeId; public Uuid TypeId;
public EpPacketAttachInfo(UUID typeId, ulong age, string link, byte[] content) public EpPacketAttachInfo(Uuid typeId, ulong age, string link, byte[] content)
{ {
TypeId = typeId; TypeId = typeId;
Age = age; Age = age;

4
Esiur/Net/Packets/HTTP/HTTPComposeOption.cs
View File

@@ -2,9 +2,9 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
namespace Esiur.Net.Packets.HTTP namespace Esiur.Net.Packets.Http
{ {
public enum HTTPComposeOption : int public enum HttpComposeOption : int
{ {
AllCalculateLength, AllCalculateLength,
AllDontCalculateLength, AllDontCalculateLength,

8
Esiur/Net/Packets/HTTP/HTTPCookie.cs
View File

@@ -2,9 +2,9 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
namespace Esiur.Net.Packets.HTTP namespace Esiur.Net.Packets.Http
{ {
public struct HTTPCookie public struct HttpCookie
{ {
public string Name; public string Name;
public string Value; public string Value;
@@ -13,7 +13,7 @@ namespace Esiur.Net.Packets.HTTP
public bool HttpOnly; public bool HttpOnly;
public string Domain; public string Domain;
public HTTPCookie(string name, string value) public HttpCookie(string name, string value)
{ {
Name = name; Name = name;
Value = value; Value = value;
@@ -23,7 +23,7 @@ namespace Esiur.Net.Packets.HTTP
Domain = null; Domain = null;
} }
public HTTPCookie(string name, string value, DateTime expires) public HttpCookie(string name, string value, DateTime expires)
{ {
Name = name; Name = name;
Value = value; Value = value;

4
Esiur/Net/Packets/HTTP/HTTPMethod.cs
View File

@@ -2,9 +2,9 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
namespace Esiur.Net.Packets.HTTP namespace Esiur.Net.Packets.Http
{ {
public enum HTTPMethod : byte public enum HttpMethod : byte
{ {
GET, GET,
POST, POST,

28
Esiur/Net/Packets/HTTP/HTTPRequestPacket.cs
View File

@@ -32,13 +32,13 @@ using Esiur.Data;
using System.Net; using System.Net;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
namespace Esiur.Net.Packets.HTTP; namespace Esiur.Net.Packets.Http;
public class HTTPRequestPacket : Packet public class HttpRequestPacket : Packet
{ {
public StringKeyList Query; public StringKeyList Query;
public HTTPMethod Method; public HttpMethod Method;
public StringKeyList Headers; public StringKeyList Headers;
public bool WSMode; public bool WSMode;
@@ -52,28 +52,28 @@ public class HTTPRequestPacket : Packet
public byte[] Message; public byte[] Message;
private HTTPMethod GetMethod(string method) private HttpMethod GetMethod(string method)
{ {
switch (method.ToLower()) switch (method.ToLower())
{ {
case "get": case "get":
return HTTPMethod.GET; return HttpMethod.GET;
case "post": case "post":
return HTTPMethod.POST; return HttpMethod.POST;
case "head": case "head":
return HTTPMethod.HEAD; return HttpMethod.HEAD;
case "put": case "put":
return HTTPMethod.PUT; return HttpMethod.PUT;
case "delete": case "delete":
return HTTPMethod.DELETE; return HttpMethod.DELETE;
case "options": case "options":
return HTTPMethod.OPTIONS; return HttpMethod.OPTIONS;
case "trace": case "trace":
return HTTPMethod.TRACE; return HttpMethod.TRACE;
case "connect": case "connect":
return HTTPMethod.CONNECT; return HttpMethod.CONNECT;
default: default:
return HTTPMethod.UNKNOWN; return HttpMethod.UNKNOWN;
} }
} }
@@ -219,7 +219,7 @@ public class HTTPRequestPacket : Packet
} }
// Post Content-Length // Post Content-Length
if (Method == HTTPMethod.POST) if (Method == HttpMethod.POST)
{ {
try try
{ {

4
Esiur/Net/Packets/HTTP/HTTPResponseCode.cs
View File

@@ -2,9 +2,9 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
namespace Esiur.Net.Packets.HTTP namespace Esiur.Net.Packets.Http
{ {
public enum HTTPResponseCode : int public enum HttpResponseCode : int
{ {
Switching = 101, Switching = 101,
OK = 200, OK = 200,

24
Esiur/Net/Packets/HTTP/HTTPResponsePacket.cs
View File

@@ -28,18 +28,18 @@ using System.Text;
using Esiur.Misc; using Esiur.Misc;
using Esiur.Data; using Esiur.Data;
namespace Esiur.Net.Packets.HTTP; namespace Esiur.Net.Packets.Http;
public class HTTPResponsePacket : Packet public class HttpResponsePacket : Packet
{ {
public StringKeyList Headers { get; } = new StringKeyList(true); public StringKeyList Headers { get; } = new StringKeyList(true);
public string Version { get; set; } = "HTTP/1.1"; public string Version { get; set; } = "HTTP/1.1";
public byte[] Message; public byte[] Message;
public HTTPResponseCode Number { get; set; } = HTTPResponseCode.OK; public HttpResponseCode Number { get; set; } = HttpResponseCode.OK;
public string Text; public string Text;
public List<HTTPCookie> Cookies { get; } = new List<HTTPCookie>(); public List<HttpCookie> Cookies { get; } = new List<HttpCookie>();
public bool Handled; public bool Handled;
public override string ToString() public override string ToString()
@@ -51,11 +51,11 @@ public class HTTPResponsePacket : Packet
+ "\n\tMessage: " + (Message != null ? Message.Length.ToString() : "NULL"); + "\n\tMessage: " + (Message != null ? Message.Length.ToString() : "NULL");
} }
private string MakeHeader(HTTPComposeOption options) private string MakeHeader(HttpComposeOption options)
{ {
string header = $"{Version} {(int)Number} {Text}\r\nServer: Esiur {Global.Version}\r\nDate: {DateTime.Now.ToUniversalTime().ToString("r")}\r\n"; string header = $"{Version} {(int)Number} {Text}\r\nServer: Esiur {Global.Version}\r\nDate: {DateTime.Now.ToUniversalTime().ToString("r")}\r\n";
if (options == HTTPComposeOption.AllCalculateLength) if (options == HttpComposeOption.AllCalculateLength)
Headers["Content-Length"] = Message?.Length.ToString() ?? "0"; Headers["Content-Length"] = Message?.Length.ToString() ?? "0";
foreach (var kv in Headers) foreach (var kv in Headers)
@@ -75,16 +75,16 @@ public class HTTPResponsePacket : Packet
} }
public bool Compose(HTTPComposeOption options) public bool Compose(HttpComposeOption options)
{ {
List<byte> msg = new List<byte>(); List<byte> msg = new List<byte>();
if (options != HTTPComposeOption.DataOnly) if (options != HttpComposeOption.DataOnly)
{ {
msg.AddRange(Encoding.UTF8.GetBytes(MakeHeader(options))); msg.AddRange(Encoding.UTF8.GetBytes(MakeHeader(options)));
} }
if (options != HTTPComposeOption.SpecifiedHeadersOnly) if (options != HttpComposeOption.SpecifiedHeadersOnly)
{ {
if (Message != null) if (Message != null)
msg.AddRange(Message); msg.AddRange(Message);
@@ -97,7 +97,7 @@ public class HTTPResponsePacket : Packet
public override bool Compose() public override bool Compose()
{ {
return Compose(HTTPComposeOption.AllDontCalculateLength); return Compose(HttpComposeOption.AllDontCalculateLength);
} }
public override long Parse(byte[] data, uint offset, uint ends) public override long Parse(byte[] data, uint offset, uint ends)
@@ -129,7 +129,7 @@ public class HTTPResponsePacket : Packet
if (sMethod.Length == 3) if (sMethod.Length == 3)
{ {
Version = sMethod[0].Trim(); Version = sMethod[0].Trim();
Number = (HTTPResponseCode)Convert.ToInt32(sMethod[1].Trim()); Number = (HttpResponseCode)Convert.ToInt32(sMethod[1].Trim());
Text = sMethod[2]; Text = sMethod[2];
} }
@@ -163,7 +163,7 @@ public class HTTPResponsePacket : Packet
if (cookie.Length >= 1) if (cookie.Length >= 1)
{ {
string[] splitCookie = cookie[0].Split('='); string[] splitCookie = cookie[0].Split('=');
HTTPCookie c = new HTTPCookie(splitCookie[0], splitCookie[1]); HttpCookie c = new HttpCookie(splitCookie[0], splitCookie[1]);
for (int j = 1; j < cookie.Length; j++) for (int j = 1; j < cookie.Length; j++)
{ {

249
Esiur/Net/Ppap/DeterministicGenerator.cs Normal file
View File

@@ -0,0 +1,249 @@
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Prng;
using Org.BouncyCastle.Security;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Ppap
{
public class DeterministicGenerator
: SecureRandom
{
private static long counter = DateTime.UtcNow.Ticks;
public byte[] value;
private static long NextCounterValue()
{
return Interlocked.Increment(ref counter);
}
private static readonly SecureRandom MasterRandom = new SecureRandom(new CryptoApiRandomGenerator());
internal static readonly SecureRandom ArbitraryRandom = new SecureRandom(new VmpcRandomGenerator(), 16);
private static DigestRandomGenerator CreatePrng(string digestName, bool autoSeed)
{
IDigest digest = DigestUtilities.GetDigest(digestName);
if (digest == null)
return null;
DigestRandomGenerator prng = new DigestRandomGenerator(digest);
if (autoSeed)
{
AutoSeed(prng, 2 * digest.GetDigestSize());
}
return prng;
}
public static new byte[] GetNextBytes(SecureRandom secureRandom, int length)
{
byte[] result = new byte[length];
secureRandom.NextBytes(result);
return result;
}
public static new SecureRandom GetInstance(string algorithm)
{
return GetInstance(algorithm, true);
}
public static new SecureRandom GetInstance(string algorithm, bool autoSeed)
{
if (algorithm == null)
throw new ArgumentNullException(nameof(algorithm));
if (algorithm.EndsWith("PRNG", StringComparison.OrdinalIgnoreCase))
{
string digestName = algorithm.Substring(0, algorithm.Length - "PRNG".Length);
DigestRandomGenerator prng = CreatePrng(digestName, autoSeed);
if (prng != null)
return new SecureRandom(prng);
}
throw new ArgumentException("Unrecognised PRNG algorithm: " + algorithm, "algorithm");
}
protected new readonly IRandomGenerator generator;
public DeterministicGenerator(byte[] value)
: this(CreatePrng("SHA256", true))
{
this.value = value;
}
public DeterministicGenerator(IRandomGenerator generator)
{
this.generator = generator;
}
public DeterministicGenerator(IRandomGenerator generator, int autoSeedLengthInBytes)
{
AutoSeed(generator, autoSeedLengthInBytes);
this.generator = generator;
}
public override byte[] GenerateSeed(int length)
{
return GetNextBytes(MasterRandom, length);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void GenerateSeed(Span<byte> seed)
{
MasterRandom.NextBytes(seed);
}
#endif
public override void SetSeed(byte[] seed)
{
generator.AddSeedMaterial(seed);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void SetSeed(Span<byte> seed)
{
generator.AddSeedMaterial(seed);
}
#endif
public override void SetSeed(long seed)
{
generator.AddSeedMaterial(seed);
}
public override int Next()
{
return NextInt() & int.MaxValue;
}
public override int Next(int maxValue)
{
if (maxValue < 2)
{
if (maxValue < 0)
throw new ArgumentOutOfRangeException("maxValue", "cannot be negative");
return 0;
}
int bits;
// Test whether maxValue is a power of 2
if ((maxValue & (maxValue - 1)) == 0)
{
bits = NextInt() & int.MaxValue;
return (int)(((long)bits * maxValue) >> 31);
}
int result;
do
{
bits = NextInt() & int.MaxValue;
result = bits % maxValue;
}
while (bits - result + (maxValue - 1) < 0); // Ignore results near overflow
return result;
}
public override int Next(int minValue, int maxValue)
{
if (maxValue <= minValue)
{
if (maxValue == minValue)
return minValue;
throw new ArgumentException("maxValue cannot be less than minValue");
}
int diff = maxValue - minValue;
if (diff > 0)
return minValue + Next(diff);
for (; ; )
{
int i = NextInt();
if (i >= minValue && i < maxValue)
return i;
}
}
public override void NextBytes(byte[] buf)
{
Buffer.BlockCopy(value, 0, buf, 0, buf.Length);
}
public override void NextBytes(byte[] buf, int off, int len)
{
Buffer.BlockCopy(value, 0, buf, off, len);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void NextBytes(Span<byte> buffer)
{
if (generator != null)
{
generator.NextBytes(buffer);
}
else
{
byte[] tmp = new byte[buffer.Length];
NextBytes(tmp);
tmp.CopyTo(buffer);
}
}
#endif
private static readonly double DoubleScale = 1.0 / Convert.ToDouble(1L << 53);
public override double NextDouble()
{
ulong x = (ulong)NextLong() >> 11;
return Convert.ToDouble(x) * DoubleScale;
}
public override int NextInt()
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> bytes = stackalloc byte[4];
#else
byte[] bytes = new byte[4];
#endif
NextBytes(bytes);
return (int)0;
}
public override long NextLong()
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> bytes = stackalloc byte[8];
#else
byte[] bytes = new byte[8];
#endif
NextBytes(bytes);
return (long)0;
}
private static void AutoSeed(IRandomGenerator generator, int seedLength)
{
generator.AddSeedMaterial(NextCounterValue());
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> seed = seedLength <= 128
? stackalloc byte[seedLength]
: new byte[seedLength];
#else
byte[] seed = new byte[seedLength];
#endif
MasterRandom.NextBytes(seed);
generator.AddSeedMaterial(seed);
}
}
}

61
Esiur/Net/Ppap/KeyGenerator.cs Normal file
View File

@@ -0,0 +1,61 @@
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Ppap
{
internal class KeyGenerator
{
public static (byte[], byte[]) Gen(MLKemParameters parameters = null)
{
var random = new RandomGenerator();
var keyGenParameters = new MLKemKeyGenerationParameters(random, parameters ?? MLKemParameters.ml_kem_768);
var kyberKeyPairGenerator = new MLKemKeyPairGenerator();
kyberKeyPairGenerator.Init(keyGenParameters);
var keys = kyberKeyPairGenerator.GenerateKeyPair();
return ((keys.Private as MLKemPrivateKeyParameters).GetEncoded(),
(keys.Public as MLKemPublicKeyParameters).GetEncoded());
}
public static (byte[], byte[]) GenS(byte[] username, byte[] password, byte[] registrationNonce, Argon2Parameters argon2parameters = null, MLKemParameters mlkemParameters = null)
{
var secret = new byte[username.Length + password.Length + registrationNonce.Length];
Buffer.BlockCopy(username, 0, secret, 0, username.Length);
Buffer.BlockCopy(password, 0, secret, username.Length, password.Length);
Buffer.BlockCopy(registrationNonce, 0, secret, username.Length + password.Length, registrationNonce.Length);
var output = new byte[64];
//Argon2id.DeriveKey(output, secret, registrationNonce, ArgonIterations, ArgonMemory * 1024);
var argon2 = new Argon2BytesGenerator();
var argon2params = argon2parameters ?? new Argon2Parameters.Builder(Argon2Parameters.Argon2id)
.WithSalt(registrationNonce)
.WithMemoryAsKB(1024 * 10)
.WithIterations(3)
.WithParallelism(1)
.Build();
argon2.Init(argon2params);
var output2 = new byte[64];
argon2.GenerateBytes(secret, output);
var random = new DeterministicGenerator(output);
var keyGenParameters = new MLKemKeyGenerationParameters(random, mlkemParameters ?? MLKemParameters.ml_kem_768);
var kyberKeyPairGenerator = new MLKemKeyPairGenerator();
kyberKeyPairGenerator.Init(keyGenParameters);
var keys = kyberKeyPairGenerator.GenerateKeyPair();
return ((keys.Private as MLKemPrivateKeyParameters).GetEncoded(),
(keys.Public as MLKemPublicKeyParameters).GetEncoded());
}
}
}

247
Esiur/Net/Ppap/RandomGenerator.cs Normal file
View File

@@ -0,0 +1,247 @@
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Prng;
using Org.BouncyCastle.Security;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Net.Ppap
{
public class RandomGenerator
: SecureRandom
{
private static long counter = DateTime.UtcNow.Ticks;
private static long NextCounterValue()
{
return Interlocked.Increment(ref counter);
}
private static readonly SecureRandom MasterRandom = new SecureRandom(new CryptoApiRandomGenerator());
internal static readonly SecureRandom ArbitraryRandom = new SecureRandom(new VmpcRandomGenerator(), 16);
private static DigestRandomGenerator CreatePrng(string digestName, bool autoSeed)
{
IDigest digest = DigestUtilities.GetDigest(digestName);
if (digest == null)
return null;
DigestRandomGenerator prng = new DigestRandomGenerator(digest);
if (autoSeed)
{
AutoSeed(prng, 2 * digest.GetDigestSize());
}
return prng;
}
public static new byte[] GetNextBytes(SecureRandom secureRandom, int length)
{
byte[] result = new byte[length];
secureRandom.NextBytes(result);
return result;
}
public static new SecureRandom GetInstance(string algorithm)
{
return GetInstance(algorithm, true);
}
public static new SecureRandom GetInstance(string algorithm, bool autoSeed)
{
if (algorithm == null)
throw new ArgumentNullException(nameof(algorithm));
if (algorithm.EndsWith("PRNG", StringComparison.OrdinalIgnoreCase))
{
string digestName = algorithm.Substring(0, algorithm.Length - "PRNG".Length);
DigestRandomGenerator prng = CreatePrng(digestName, autoSeed);
if (prng != null)
return new SecureRandom(prng);
}
throw new ArgumentException("Unrecognised PRNG algorithm: " + algorithm, "algorithm");
}
protected new readonly IRandomGenerator generator;
public RandomGenerator()
: this(CreatePrng("SHA256", true))
{
}
public RandomGenerator(IRandomGenerator generator)
{
this.generator = generator;
}
public RandomGenerator(IRandomGenerator generator, int autoSeedLengthInBytes)
{
AutoSeed(generator, autoSeedLengthInBytes);
this.generator = generator;
}
public override byte[] GenerateSeed(int length)
{
return GetNextBytes(MasterRandom, length);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void GenerateSeed(Span<byte> seed)
{
MasterRandom.NextBytes(seed);
}
#endif
public override void SetSeed(byte[] seed)
{
generator.AddSeedMaterial(seed);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void SetSeed(Span<byte> seed)
{
generator.AddSeedMaterial(seed);
}
#endif
public override void SetSeed(long seed)
{
generator.AddSeedMaterial(seed);
}
public override int Next()
{
return NextInt() & int.MaxValue;
}
public override int Next(int maxValue)
{
if (maxValue < 2)
{
if (maxValue < 0)
throw new ArgumentOutOfRangeException("maxValue", "cannot be negative");
return 0;
}
int bits;
// Test whether maxValue is a power of 2
if ((maxValue & (maxValue - 1)) == 0)
{
bits = NextInt() & int.MaxValue;
return (int)(((long)bits * maxValue) >> 31);
}
int result;
do
{
bits = NextInt() & int.MaxValue;
result = bits % maxValue;
}
while (bits - result + (maxValue - 1) < 0); // Ignore results near overflow
return result;
}
public override int Next(int minValue, int maxValue)
{
if (maxValue <= minValue)
{
if (maxValue == minValue)
return minValue;
throw new ArgumentException("maxValue cannot be less than minValue");
}
int diff = maxValue - minValue;
if (diff > 0)
return minValue + Next(diff);
for (; ; )
{
int i = NextInt();
if (i >= minValue && i < maxValue)
return i;
}
}
public override void NextBytes(byte[] buf)
{
generator.NextBytes(buf);
}
public override void NextBytes(byte[] buf, int off, int len)
{
generator.NextBytes(buf, off, len);
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public override void NextBytes(Span<byte> buffer)
{
if (generator != null)
{
generator.NextBytes(buffer);
}
else
{
byte[] tmp = new byte[buffer.Length];
NextBytes(tmp);
tmp.CopyTo(buffer);
}
}
#endif
private static readonly double DoubleScale = 1.0 / Convert.ToDouble(1L << 53);
public override double NextDouble()
{
ulong x = (ulong)NextLong() >> 11;
return Convert.ToDouble(x) * DoubleScale;
}
public override int NextInt()
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> bytes = stackalloc byte[4];
#else
byte[] bytes = new byte[4];
#endif
NextBytes(bytes);
return (int)0;
}
public override long NextLong()
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> bytes = stackalloc byte[8];
#else
byte[] bytes = new byte[8];
#endif
NextBytes(bytes);
return (long)0;
}
private static void AutoSeed(IRandomGenerator generator, int seedLength)
{
generator.AddSeedMaterial(NextCounterValue());
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
Span<byte> seed = seedLength <= 128
? stackalloc byte[seedLength]
: new byte[seedLength];
#else
byte[] seed = new byte[seedLength];
#endif
MasterRandom.NextBytes(seed);
generator.AddSeedMaterial(seed);
}
}
}

6
Esiur/Net/TCP/TCPConnection.cs
View File

@@ -32,13 +32,13 @@ using System.Collections;
using Esiur.Misc; using Esiur.Misc;
using Esiur.Data; using Esiur.Data;
namespace Esiur.Net.TCP; namespace Esiur.Net.Tcp;
public class TCPConnection : NetworkConnection public class TcpConnection : NetworkConnection
{ {
private KeyList<string, object> variables = new KeyList<string, object>(); private KeyList<string, object> variables = new KeyList<string, object>();
public TCPServer Server { get; internal set; } public TcpServer Server { get; internal set; }
public KeyList<string, object> Variables public KeyList<string, object> Variables
{ {

10
Esiur/Net/TCP/TCPFilter.cs
View File

@@ -32,9 +32,9 @@ using Esiur.Net.Sockets;
using Esiur.Core; using Esiur.Core;
using Esiur.Resource; using Esiur.Resource;
namespace Esiur.Net.TCP; namespace Esiur.Net.Tcp;
public abstract class TCPFilter : IResource public abstract class TcpFilter : IResource
{ {
public Instance Instance public Instance Instance
@@ -48,17 +48,17 @@ public abstract class TCPFilter : IResource
public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger); public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
public virtual bool Connected(TCPConnection sender) public virtual bool Connected(TcpConnection sender)
{ {
return false; return false;
} }
public virtual bool Disconnected(TCPConnection sender) public virtual bool Disconnected(TcpConnection sender)
{ {
return false; return false;
} }
public abstract bool Execute(byte[] msg, NetworkBuffer data, TCPConnection sender); public abstract bool Execute(byte[] msg, NetworkBuffer data, TcpConnection sender);
public void Destroy() public void Destroy()
{ {

20
Esiur/Net/TCP/TCPServer.cs
View File

@@ -34,8 +34,8 @@ using Esiur.Core;
using System.Net; using System.Net;
using Esiur.Resource; using Esiur.Resource;
namespace Esiur.Net.TCP; namespace Esiur.Net.Tcp;
public class TCPServer : NetworkServer<TCPConnection>, IResource public class TcpServer : NetworkServer<TcpConnection>, IResource
{ {
[Attribute] [Attribute]
@@ -64,7 +64,7 @@ public class TCPServer : NetworkServer<TCPConnection>, IResource
//} //}
public Instance Instance { get; set; } public Instance Instance { get; set; }
TCPFilter[] filters = null; TcpFilter[] filters = null;
public AsyncReply<bool> Trigger(ResourceTrigger trigger) public AsyncReply<bool> Trigger(ResourceTrigger trigger)
{ {
@@ -93,7 +93,7 @@ public class TCPServer : NetworkServer<TCPConnection>, IResource
} }
else if (trigger == ResourceTrigger.SystemInitialized) else if (trigger == ResourceTrigger.SystemInitialized)
{ {
Instance.Children<TCPFilter>().Then(x => filters = x); Instance.Children<TcpFilter>().Then(x => filters = x);
} }
return new AsyncReply<bool>(true); return new AsyncReply<bool>(true);
@@ -103,7 +103,7 @@ public class TCPServer : NetworkServer<TCPConnection>, IResource
internal bool Execute(TCPConnection sender, NetworkBuffer data) internal bool Execute(TcpConnection sender, NetworkBuffer data)
{ {
if (filters == null) if (filters == null)
@@ -120,12 +120,12 @@ public class TCPServer : NetworkServer<TCPConnection>, IResource
return false; return false;
} }
private void SessionModified(TCPConnection session, string key, object newValue) private void SessionModified(TcpConnection session, string key, object newValue)
{ {
} }
protected override void ClientDisconnected(TCPConnection connection) protected override void ClientDisconnected(TcpConnection connection)
{ {
if (filters == null) if (filters == null)
return; return;
@@ -136,19 +136,19 @@ public class TCPServer : NetworkServer<TCPConnection>, IResource
} }
} }
public override void Add(TCPConnection connection) public override void Add(TcpConnection connection)
{ {
connection.Server = this; connection.Server = this;
base.Add(connection); base.Add(connection);
} }
public override void Remove(TCPConnection connection) public override void Remove(TcpConnection connection)
{ {
connection.Server = null; connection.Server = null;
base.Remove(connection); base.Remove(connection);
} }
protected override void ClientConnected(TCPConnection connection) protected override void ClientConnected(TcpConnection connection)
{ {
if (filters == null) if (filters == null)
return; return;

4
Esiur/Net/TCP/TCPSession.cs
View File

@@ -28,8 +28,8 @@ using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Esiur.Net.TCP; namespace Esiur.Net.Tcp;
public class TCPSession : NetworkSession public class TcpSession : NetworkSession
{ {
} }

2
Esiur/Net/UDP/UDPFilter.cs
View File

@@ -33,7 +33,7 @@ using Esiur.Core;
using Esiur.Resource; using Esiur.Resource;
namespace Esiur.Net.UDP; namespace Esiur.Net.UDP;
public abstract class UDPFilter : IResource public abstract class UdpFilter : IResource
{ {

8
Esiur/Net/UDP/UDPServer.cs
View File

@@ -40,11 +40,11 @@ namespace Esiur.Net.UDP;
public EndPoint SenderPoint; public EndPoint SenderPoint;
public public
}*/ }*/
public class UDPServer : IResource public class UdpServer : IResource
{ {
Thread receiver; Thread receiver;
UdpClient udp; UdpClient udp;
UDPFilter[] filters = new UDPFilter[0]; UdpFilter[] filters = new UdpFilter[0];
public event DestroyedEvent OnDestroy; public event DestroyedEvent OnDestroy;
@@ -80,7 +80,7 @@ public class UDPServer : IResource
foreach (var child in filters) foreach (var child in filters)
{ {
var f = child as UDPFilter; var f = child as UdpFilter;
try try
{ {
@@ -195,7 +195,7 @@ public class UDPServer : IResource
} }
else if (trigger == ResourceTrigger.SystemInitialized) else if (trigger == ResourceTrigger.SystemInitialized)
{ {
filters = await Instance.Children<UDPFilter>(); filters = await Instance.Children<UdpFilter>();
} }
return true; return true;

20
Esiur/Protocol/Authentication/HashAnonymousAuthenticator.cs Normal file
View File

@@ -0,0 +1,20 @@
using Esiur.Security.Authority;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Protocol.Authentication
{
public class HashAnonymousAuthenticator : IAuthenticationHandler
{
public AuthenticationResult Initiate(Session session)
{
throw new NotImplementedException();
}
public AuthenticationResult Process(object handshakePayload)
{
throw new NotImplementedException();
}
}
}

1710
Esiur/Protocol/EpConnection.cs
View File

File diff suppressed because it is too large Load Diff

84
Esiur/Protocol/EpConnectionProtocol.cs
View File

@@ -50,12 +50,12 @@ partial class EpConnection
KeyList<uint, WeakReference<EpResource>> suspendedResources = new KeyList<uint, WeakReference<EpResource>>(); KeyList<uint, WeakReference<EpResource>> suspendedResources = new KeyList<uint, WeakReference<EpResource>>();
KeyList<uint, EpResourceAttachRequestInfo> resourceRequests = new KeyList<uint, EpResourceAttachRequestInfo>(); KeyList<uint, EpResourceAttachRequestInfo> resourceRequests = new KeyList<uint, EpResourceAttachRequestInfo>();
KeyList<UUID, AsyncReply<TypeDef>> typeDefsByIdRequests = new KeyList<UUID, AsyncReply<TypeDef>>(); KeyList<Uuid, AsyncReply<TypeDef>> typeDefsByIdRequests = new KeyList<Uuid, AsyncReply<TypeDef>>();
KeyList<string, AsyncReply<TypeDef>> typeDefsByNameRequests = new KeyList<string, AsyncReply<TypeDef>>(); KeyList<string, AsyncReply<TypeDef>> typeDefsByNameRequests = new KeyList<string, AsyncReply<TypeDef>>();
Dictionary<UUID, TypeDef> typeDefs = new Dictionary<UUID, TypeDef>(); Dictionary<Uuid, TypeDef> typeDefs = new Dictionary<Uuid, TypeDef>();
KeyList<uint, AsyncReply> requests = new KeyList<uint, AsyncReply>(); KeyList<uint, AsyncReply> requests = new KeyList<uint, AsyncReply>();
@@ -186,7 +186,7 @@ partial class EpConnection
} }
public AsyncReply StaticCall(UUID typeId, byte index, object parameters) public AsyncReply StaticCall(Uuid typeId, byte index, object parameters)
{ {
return SendRequest(EpPacketRequest.StaticCall, typeId, index, parameters); return SendRequest(EpPacketRequest.StaticCall, typeId, index, parameters);
} }
@@ -270,7 +270,7 @@ partial class EpConnection
SendReply(EpPacketReply.Chunk, callbackId, chunk); SendReply(EpPacketReply.Chunk, callbackId, chunk);
} }
void EpReplyCompleted(uint callbackId, ParsedTDU dataType) void EpReplyCompleted(uint callbackId, ParsedTdu dataType)
{ {
var req = requests.Take(callbackId); var req = requests.Take(callbackId);
@@ -301,12 +301,12 @@ partial class EpConnection
} }
} }
void EpExtensionAction(byte actionId, ParsedTDU? dataType, byte[] data) void EpExtensionAction(byte actionId, ParsedTdu? dataType, byte[] data)
{ {
// nothing is supported now // nothing is supported now
} }
void EpReplyPropagated(uint callbackId, ParsedTDU dataType, byte[] data) void EpReplyPropagated(uint callbackId, ParsedTdu dataType, byte[] data)
{ {
var req = requests[callbackId]; var req = requests[callbackId];
@@ -330,7 +330,7 @@ partial class EpConnection
} }
} }
void EpReplyError(uint callbackId, ParsedTDU dataType, byte[] data, ErrorType type) void EpReplyError(uint callbackId, ParsedTdu dataType, byte[] data, ErrorType type)
{ {
var req = requests.Take(callbackId); var req = requests.Take(callbackId);
@@ -349,7 +349,7 @@ partial class EpConnection
req.TriggerError(new AsyncException(type, errorCode, errorMsg)); req.TriggerError(new AsyncException(type, errorCode, errorMsg));
} }
void EpReplyProgress(uint callbackId, ParsedTDU dataType, byte[] data) void EpReplyProgress(uint callbackId, ParsedTdu dataType, byte[] data)
{ {
var req = requests[callbackId]; var req = requests[callbackId];
@@ -368,7 +368,7 @@ partial class EpConnection
req.TriggerProgress(ProgressType.Execution, current, total); req.TriggerProgress(ProgressType.Execution, current, total);
} }
void EpReplyWarning(uint callbackId, ParsedTDU dataType, byte[] data) void EpReplyWarning(uint callbackId, ParsedTdu dataType, byte[] data)
{ {
var req = requests[callbackId]; var req = requests[callbackId];
@@ -389,7 +389,7 @@ partial class EpConnection
void EpReplyChunk(uint callbackId, ParsedTDU dataType) void EpReplyChunk(uint callbackId, ParsedTdu dataType)
{ {
var req = requests[callbackId]; var req = requests[callbackId];
@@ -404,16 +404,16 @@ partial class EpConnection
req.TriggerChunk(parsed); req.TriggerChunk(parsed);
} }
void EpNotificationResourceReassigned(ParsedTDU dataType) void EpNotificationResourceReassigned(ParsedTdu dataType)
{ {
// uint resourceId, uint newResourceId // uint resourceId, uint newResourceId
} }
void EpNotificationResourceMoved(ParsedTDU dataType, byte[] data) { } void EpNotificationResourceMoved(ParsedTdu dataType, byte[] data) { }
void EpNotificationSystemFailure(ParsedTDU dataType, byte[] data) { } void EpNotificationSystemFailure(ParsedTdu dataType, byte[] data) { }
void EpNotificationResourceDestroyed(ParsedTDU dataType, byte[] data) void EpNotificationResourceDestroyed(ParsedTdu dataType, byte[] data)
{ {
var (size, rt) = Codec.ParseSync(dataType, Instance.Warehouse); var (size, rt) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -444,7 +444,7 @@ partial class EpConnection
} }
void EpNotificationPropertyModified(ParsedTDU dataType) void EpNotificationPropertyModified(ParsedTdu dataType)
{ {
// resourceId, index, value // resourceId, index, value
var (valueOffset, valueSize, args) = var (valueOffset, valueSize, args) =
@@ -488,7 +488,7 @@ partial class EpConnection
} }
void EpNotificationEventOccurred(ParsedTDU dataType, byte[] data) void EpNotificationEventOccurred(ParsedTdu dataType, byte[] data)
{ {
// resourceId, index, value // resourceId, index, value
var (valueOffset, valueSize, args) = var (valueOffset, valueSize, args) =
@@ -537,7 +537,7 @@ partial class EpConnection
}); });
} }
void EpRequestAttachResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestAttachResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -579,7 +579,7 @@ partial class EpConnection
}); });
} }
void EpRequestReattachResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestReattachResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
// resourceId, index, value // resourceId, index, value
var (valueOffset, valueSize, args) = var (valueOffset, valueSize, args) =
@@ -627,7 +627,7 @@ partial class EpConnection
}); });
} }
void EpRequestDetachResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestDetachResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -658,7 +658,7 @@ partial class EpConnection
}); });
} }
void EpRequestCreateResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestCreateResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, parsed) = Codec.ParseAsync(dataType, this, null); var (_, parsed) = Codec.ParseAsync(dataType, this, null);
@@ -668,8 +668,8 @@ partial class EpConnection
TypeDef type = null; TypeDef type = null;
if (args[1] is UUID) if (args[1] is Uuid)
type = Instance.Warehouse.GetTypeDefById((UUID)args[1]); type = Instance.Warehouse.GetTypeDefById((Uuid)args[1]);
else if (args[1] is string) else if (args[1] is string)
type = Instance.Warehouse.GetTypeDefByName((string)args[1]); type = Instance.Warehouse.GetTypeDefByName((string)args[1]);
@@ -719,7 +719,7 @@ partial class EpConnection
} }
void EpRequestDeleteResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestDeleteResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -748,7 +748,7 @@ partial class EpConnection
}); });
} }
void EpRequestMoveResource(uint callback, ParsedTDU dataType, byte[] data) void EpRequestMoveResource(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
@@ -789,12 +789,12 @@ partial class EpConnection
void EpRequestToken(uint callback, ParsedTDU dataType, byte[] data) void EpRequestToken(uint callback, ParsedTdu dataType, byte[] data)
{ {
// @TODO: To be implemented // @TODO: To be implemented
} }
void EpRequestLinkTypeDefs(uint callback, ParsedTDU dataType, byte[] data) void EpRequestLinkTypeDefs(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -827,7 +827,7 @@ partial class EpConnection
Instance.Warehouse.Query(resourceLink).Then(queryCallback); Instance.Warehouse.Query(resourceLink).Then(queryCallback);
} }
void EpRequestTypeDefByName(uint callback, ParsedTDU dataType, byte[] data) void EpRequestTypeDefByName(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -846,12 +846,12 @@ partial class EpConnection
} }
} }
void EpRequestTypeDefById(uint callback, ParsedTDU dataType, byte[] data) void EpRequestTypeDefById(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
var typeId = (UUID)value; var typeId = (Uuid)value;
var t = Instance.Warehouse.GetTypeDefById(typeId); var t = Instance.Warehouse.GetTypeDefById(typeId);
@@ -868,7 +868,7 @@ partial class EpConnection
void EpRequestTypeDefByResourceId(uint callback, ParsedTDU dataType, byte[] data) void EpRequestTypeDefByResourceId(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, value) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -891,7 +891,7 @@ partial class EpConnection
void EpRequestGetResourceIdByLink(uint callback, ParsedTDU dataType, byte[] data) void EpRequestGetResourceIdByLink(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, parsed) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, parsed) = Codec.ParseSync(dataType, Instance.Warehouse);
var resourceLink = (string)parsed; var resourceLink = (string)parsed;
@@ -919,7 +919,7 @@ partial class EpConnection
} }
void EpRequestQueryResources(uint callback, ParsedTDU dataType, byte[] data) void EpRequestQueryResources(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (_, parsed) = Codec.ParseSync(dataType, Instance.Warehouse); var (_, parsed) = Codec.ParseSync(dataType, Instance.Warehouse);
@@ -977,7 +977,7 @@ partial class EpConnection
} }
void EpRequestProcedureCall(uint callback, ParsedTDU dataType, byte[] data) void EpRequestProcedureCall(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
dataType.ContentLength, Instance.Warehouse, 1); dataType.ContentLength, Instance.Warehouse, 1);
@@ -1037,12 +1037,12 @@ partial class EpConnection
} }
} }
void EpRequestStaticCall(uint callback, ParsedTDU dataType, byte[] data) void EpRequestStaticCall(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
dataType.ContentLength, Instance.Warehouse, 2); dataType.ContentLength, Instance.Warehouse, 2);
var typeId = new UUID((byte[])args[0]); var typeId = new Uuid((byte[])args[0]);
var index = (byte)args[1]; var index = (byte)args[1];
@@ -1114,7 +1114,7 @@ partial class EpConnection
} }
} }
void EpRequestInvokeFunction(uint callback, ParsedTDU dataType, byte[] data) void EpRequestInvokeFunction(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
dataType.ContentLength, Instance.Warehouse, 2); dataType.ContentLength, Instance.Warehouse, 2);
@@ -1466,7 +1466,7 @@ partial class EpConnection
} }
} }
void EpRequestSubscribe(uint callback, ParsedTDU dataType, byte[] data) void EpRequestSubscribe(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
@@ -1525,7 +1525,7 @@ partial class EpConnection
} }
void EpRequestUnsubscribe(uint callback, ParsedTDU dataType, byte[] data) void EpRequestUnsubscribe(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
@@ -1586,7 +1586,7 @@ partial class EpConnection
void EpRequestSetProperty(uint callback, ParsedTDU dataType, byte[] data) void EpRequestSetProperty(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,
@@ -1719,7 +1719,7 @@ partial class EpConnection
/// </summary> /// </summary>
/// <param name="typeId">Type UUID.</param> /// <param name="typeId">Type UUID.</param>
/// <returns>TypeSchema.</returns> /// <returns>TypeSchema.</returns>
public AsyncReply<TypeDef> GetTypeDefById(UUID typeId) public AsyncReply<TypeDef> GetTypeDefById(Uuid typeId)
{ {
if (typeDefs.ContainsKey(typeId)) if (typeDefs.ContainsKey(typeId))
return new AsyncReply<TypeDef>(typeDefs[typeId]); return new AsyncReply<TypeDef>(typeDefs[typeId]);
@@ -1902,7 +1902,7 @@ partial class EpConnection
// TypeId, Age, Link, Hops, PropertyValue[] // TypeId, Age, Link, Hops, PropertyValue[]
var args = (object[])result; var args = (object[])result;
var typeId = (UUID)args[0]; var typeId = (Uuid)args[0];
var age = Convert.ToUInt64(args[1]); var age = Convert.ToUInt64(args[1]);
var link = (string)args[2]; var link = (string)args[2];
var hops = (byte)args[3]; var hops = (byte)args[3];
@@ -2156,7 +2156,7 @@ partial class EpConnection
void EpRequestKeepAlive(uint callback, ParsedTDU dataType, byte[] data) void EpRequestKeepAlive(uint callback, ParsedTdu dataType, byte[] data)
{ {
var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset, var (offset, length, args) = DataDeserializer.LimitedCountListParser(data, dataType.Offset,

22
Esiur/Protocol/EpServer.cs
View File

@@ -59,23 +59,23 @@ public class EpServer : NetworkServer<EpConnection>, IResource
get => membership; get => membership;
set set
{ {
if (membership != null) //if (membership != null)
membership.Authorization -= Membership_Authorization; // membership.Authorization -= Membership_Authorization;
membership = value; membership = value;
if (membership != null) //if (membership != null)
membership.Authorization += Membership_Authorization; // membership.Authorization += Membership_Authorization;
} }
} }
private void Membership_Authorization(AuthorizationIndication indication) //private void Membership_Authorization(AuthorizationIndication indication)
{ //{
lock (Connections.SyncRoot) // lock (Connections.SyncRoot)
foreach (var connection in Connections) // foreach (var connection in Connections)
if (connection.Session == indication.Session) // if (connection.Session == indication.Session)
connection.ProcessAuthorization(indication.Results); // connection.ProcessAuthorization(indication.Results);
} //}
[Attribute] [Attribute]
public EntryPoint EntryPoint public EntryPoint EntryPoint

37
Esiur/Protocol/EpSession.cs
View File

@@ -1,37 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Text;
using Esiur.Net;
using Esiur.Net.Sockets;
using Esiur.Security.Authority;
namespace Esiur.Protocol;
public class EpSession : NetworkSession
{
public Source Source { get; set; }
public Authentication Authentication { get; set; }
}

64
Esiur/Proxy/TypeDefGenerator.cs
View File

@@ -140,28 +140,28 @@ public static class TypeDefGenerator
} }
static string GetTypeName(TRU tru, TypeDef[] typeDefs) static string GetTypeName(Tru tru, TypeDef[] typeDefs)
{ {
string name; string name;
if (tru.Identifier == TRUIdentifier.TypedResource)// == DataType.Resource) if (tru.Identifier == TruIdentifier.TypedResource)// == DataType.Resource)
name = typeDefs.First(x => x.Id == tru.UUID && (x.Kind == TypeDefKind.Resource)).Name; name = typeDefs.First(x => x.Id == tru.UUID && (x.Kind == TypeDefKind.Resource)).Name;
else if (tru.Identifier == TRUIdentifier.TypedRecord) else if (tru.Identifier == TruIdentifier.TypedRecord)
name = typeDefs.First(x => x.Id == tru.UUID && x.Kind == TypeDefKind.Record).Name; name = typeDefs.First(x => x.Id == tru.UUID && x.Kind == TypeDefKind.Record).Name;
else if (tru.Identifier == TRUIdentifier.Enum) else if (tru.Identifier == TruIdentifier.Enum)
name = typeDefs.First(x => x.Id == tru.UUID && x.Kind == TypeDefKind.Enum).Name; name = typeDefs.First(x => x.Id == tru.UUID && x.Kind == TypeDefKind.Enum).Name;
else if (tru.Identifier == TRUIdentifier.TypedList) else if (tru.Identifier == TruIdentifier.TypedList)
name = GetTypeName(tru.SubTypes[0], typeDefs) + "[]"; name = GetTypeName(tru.SubTypes[0], typeDefs) + "[]";
else if (tru.Identifier == TRUIdentifier.TypedMap) else if (tru.Identifier == TruIdentifier.TypedMap)
name = "Map<" + GetTypeName(tru.SubTypes[0], typeDefs) name = "Map<" + GetTypeName(tru.SubTypes[0], typeDefs)
+ "," + GetTypeName(tru.SubTypes[1], typeDefs) + "," + GetTypeName(tru.SubTypes[1], typeDefs)
+ ">"; + ">";
else if (tru.Identifier == TRUIdentifier.Tuple2 || else if (tru.Identifier == TruIdentifier.Tuple2 ||
tru.Identifier == TRUIdentifier.Tuple3 || tru.Identifier == TruIdentifier.Tuple3 ||
tru.Identifier == TRUIdentifier.Tuple4 || tru.Identifier == TruIdentifier.Tuple4 ||
tru.Identifier == TRUIdentifier.Tuple5 || tru.Identifier == TruIdentifier.Tuple5 ||
tru.Identifier == TRUIdentifier.Tuple6 || tru.Identifier == TruIdentifier.Tuple6 ||
tru.Identifier == TRUIdentifier.Tuple7) tru.Identifier == TruIdentifier.Tuple7)
name = "(" + String.Join(",", tru.SubTypes.Select(x => GetTypeName(x, typeDefs))) name = "(" + String.Join(",", tru.SubTypes.Select(x => GetTypeName(x, typeDefs)))
+ ")"; + ")";
else else
@@ -169,26 +169,26 @@ public static class TypeDefGenerator
name = tru.Identifier switch name = tru.Identifier switch
{ {
TRUIdentifier.Dynamic => "object", TruIdentifier.Dynamic => "object",
TRUIdentifier.Bool => "bool", TruIdentifier.Bool => "bool",
TRUIdentifier.Char => "char", TruIdentifier.Char => "char",
TRUIdentifier.DateTime => "DateTime", TruIdentifier.DateTime => "DateTime",
TRUIdentifier.Decimal => "decimal", TruIdentifier.Decimal => "decimal",
TRUIdentifier.Float32 => "float", TruIdentifier.Float32 => "float",
TRUIdentifier.Float64 => "double", TruIdentifier.Float64 => "double",
TRUIdentifier.Int16 => "short", TruIdentifier.Int16 => "short",
TRUIdentifier.Int32 => "int", TruIdentifier.Int32 => "int",
TRUIdentifier.Int64 => "long", TruIdentifier.Int64 => "long",
TRUIdentifier.Int8 => "sbyte", TruIdentifier.Int8 => "sbyte",
TRUIdentifier.String => "string", TruIdentifier.String => "string",
TRUIdentifier.Map => "Map<object, object>", TruIdentifier.Map => "Map<object, object>",
TRUIdentifier.UInt16 => "ushort", TruIdentifier.UInt16 => "ushort",
TRUIdentifier.UInt32 => "uint", TruIdentifier.UInt32 => "uint",
TRUIdentifier.UInt64 => "ulong", TruIdentifier.UInt64 => "ulong",
TRUIdentifier.UInt8 => "byte", TruIdentifier.UInt8 => "byte",
TRUIdentifier.List => "object[]", TruIdentifier.List => "object[]",
TRUIdentifier.Resource => "IResource", TruIdentifier.Resource => "IResource",
TRUIdentifier.Record => "IRecord", TruIdentifier.Record => "IRecord",
_ => "object" _ => "object"
}; };
} }

6
Esiur/Resource/Storable.cs
View File

@@ -40,7 +40,7 @@ public class Storable : global::System.Attribute
SerializerFunction serializer; SerializerFunction serializer;
DeserializerFunction deserializer; DeserializerFunction deserializer;
TRU dataType; Tru dataType;
public Storable() public Storable()
{ {
@@ -57,12 +57,12 @@ public class Storable : global::System.Attribute
get { return serializer; } get { return serializer; }
} }
public Storable(TRU type) public Storable(Tru type)
{ {
this.dataType = type; this.dataType = type;
} }
public Storable(TRU type, SerializerFunction serializer, DeserializerFunction deserializer) public Storable(Tru type, SerializerFunction serializer, DeserializerFunction deserializer)
{ {
this.dataType = type; this.dataType = type;
this.serializer = serializer; this.serializer = serializer;

4
Esiur/Resource/TypeIdAttribute.cs
View File

@@ -8,12 +8,12 @@ namespace Esiur.Resource
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Enum)] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Enum)]
public class TypeIdAttribute : Attribute public class TypeIdAttribute : Attribute
{ {
public UUID Id { get; private set; } public Uuid Id { get; private set; }
public TypeIdAttribute(string id) public TypeIdAttribute(string id)
{ {
var data = DC.FromHex(id, null); var data = DC.FromHex(id, null);
Id = new UUID(data); Id = new Uuid(data);
} }
} }
} }

12
Esiur/Resource/Warehouse.cs
View File

@@ -59,12 +59,12 @@ public class Warehouse
uint resourceCounter = 0; uint resourceCounter = 0;
KeyList<TypeDefKind, KeyList<UUID, TypeDef>> typeDefs KeyList<TypeDefKind, KeyList<Uuid, TypeDef>> typeDefs
= new KeyList<TypeDefKind, KeyList<UUID, TypeDef>>() = new KeyList<TypeDefKind, KeyList<Uuid, TypeDef>>()
{ {
[TypeDefKind.Resource] = new KeyList<UUID, TypeDef>(), [TypeDefKind.Resource] = new KeyList<Uuid, TypeDef>(),
[TypeDefKind.Record] = new KeyList<UUID, TypeDef>(), [TypeDefKind.Record] = new KeyList<Uuid, TypeDef>(),
[TypeDefKind.Enum] = new KeyList<UUID, TypeDef>(), [TypeDefKind.Enum] = new KeyList<Uuid, TypeDef>(),
}; };
bool warehouseIsOpen = false; bool warehouseIsOpen = false;
@@ -557,7 +557,7 @@ public class Warehouse
/// </summary> /// </summary>
/// <param name="typeId">typeId.</param> /// <param name="typeId">typeId.</param>
/// <returns>TypeDef.</returns> /// <returns>TypeDef.</returns>
public TypeDef GetTypeDefById(UUID typeId, TypeDefKind? typeDefKind = null) public TypeDef GetTypeDefById(Uuid typeId, TypeDefKind? typeDefKind = null)
{ {
if (typeDefKind == null) if (typeDefKind == null)
{ {

40
Esiur/Security/Authority/AlienAuthentication.cs
View File

@@ -1,40 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class AlienAuthentication : Authentication
{
public AlienAuthentication() :
base(AuthenticationType.Alien)
{
}
}

6
Esiur/Security/Authority/Authentication.cs
View File

@@ -32,7 +32,7 @@ namespace Esiur.Security.Authority;
public class Authentication public class Authentication
{ {
AuthenticationType type; AuthenticationMode type;
public AuthenticationMethod Method { get; set; } public AuthenticationMethod Method { get; set; }
@@ -52,12 +52,12 @@ public class Authentication
set; set;
} }
public AuthenticationType Type public AuthenticationMode Type
{ {
get => type; get => type;
} }
public Authentication(AuthenticationType type) public Authentication(AuthenticationMode type)
{ {
this.type = type; this.type = type;
} }

11
Esiur/Security/Authority/AuthenticationMethod.cs
View File

@@ -7,7 +7,12 @@ namespace Esiur.Security.Authority;
public enum AuthenticationMethod : byte public enum AuthenticationMethod : byte
{ {
None, None,
Credentials, PpapCredentialsAnonymous,
Token, PpapCredentialsCredentials,
Certificate PpapCredentialsHec,
PpapHecAnonymous,
PpapHecCredentials,
PpapHecHec,
HashAnonymous,
} }

10
Esiur/Security/Authority/AuthenticationType.cs → Esiur/Security/Authority/AuthenticationMode.cs
View File

@@ -30,10 +30,10 @@ using System.Threading.Tasks;
namespace Esiur.Security.Authority; namespace Esiur.Security.Authority;
public enum AuthenticationType public enum AuthenticationMode:byte
{ {
Host, None = 0x0,
CoHost, InitializerIdentity = 0x1,
Client, ResponderIdentity = 0x2,
Alien DualIdentity = 0x3,
} }

28
Esiur/Security/Authority/AuthenticationResult.cs Normal file
View File

@@ -0,0 +1,28 @@
using Esiur.Core;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Authority
{
public class AuthenticationResult
{
public AuthenticationRuling Ruling { get; internal set; }
public string Identity { get; internal set; }
public object HandshakePayload { get; internal set; }
public byte[] SessionKey { get; internal set; }
public ExceptionCode? ExceptionCode { get; internal set; }
public string ExceptionMessage { get; internal set; }
public AuthenticationResult(AuthenticationRuling ruling, string identity, object handshakePayload, byte[] sessionKey)
{
Ruling = ruling;
Identity = identity;
HandshakePayload = handshakePayload;
SessionKey = sessionKey;
}
}
}

13
Esiur/Security/Authority/AuthenticationRuling.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Authority
{
public enum AuthenticationRuling
{
Failed,
InProgress,
Succeeded,
}
}

201
Esiur/Security/Authority/CACertificate.cs
View File

@@ -1,201 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using Esiur.Data;
using Esiur.Core;
using Esiur.Misc;
using Esiur.Security.Cryptography;
using Esiur.Security.Integrity;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class CACertificate : Certificate
{
string name;
public string Name
{
get { return name; }
}
public CACertificate(byte[] data, uint offset, uint length, bool privateKeyIncluded = false)
: base(0, DateTime.MinValue, DateTime.MinValue, HashFunctionType.MD5)
{
uint oOffset = offset;
this.id = DC.GetUInt64(data, offset, Endian.Little);
offset += 8;
this.issueDate = DC.GetDateTime(data, offset, Endian.Little);
offset += 8;
this.expireDate = DC.GetDateTime(data, offset, Endian.Little);
offset += 8;
this.hashFunction = (HashFunctionType)(data[offset++] >> 4);
this.name = (Encoding.ASCII.GetString(data, (int)offset + 1, data[offset]));
offset += (uint)data[offset] + 1;
var aea = (AsymetricEncryptionAlgorithmType)(data[offset] >> 5);
if (aea == AsymetricEncryptionAlgorithmType.RSA)
{
var key = new RSAParameters();
uint exponentLength = (uint)data[offset++] & 0x1F;
key.Exponent = DC.Clip(data, offset, exponentLength);
offset += exponentLength;
uint keySize = DC.GetUInt16(data, offset, Endian.Little);
offset += 2;
key.Modulus = DC.Clip(data, offset, keySize);
offset += keySize;
// copy cert data
this.publicRawData = new byte[offset - oOffset];
Buffer.BlockCopy(data, (int)oOffset, publicRawData, 0, publicRawData.Length);
if (privateKeyIncluded)
{
uint privateKeyLength = (keySize * 3) + (keySize / 2);
uint halfKeySize = keySize / 2;
privateRawData = DC.Clip(data, offset, privateKeyLength);
key.D = DC.Clip(data, offset, keySize);
offset += keySize;
key.DP = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.DQ = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.InverseQ = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.P = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.Q = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
}
// setup rsa
this.rsa = RSA.Create();// new RSACryptoServiceProvider();
this.rsa.ImportParameters(key);
}
}
public CACertificate(ulong id, string authorityName, DateTime issueDate, DateTime expireDate,
HashFunctionType hashFunction = HashFunctionType.SHA1, uint ip = 0, byte[] ip6 = null)
: base(id, issueDate, expireDate, hashFunction)
{
// assign type
BinaryList cr = new BinaryList();
// make header
cr.AddUInt64(id)
.AddDateTime(issueDate)
.AddDateTime(expireDate);
// hash function
cr.AddUInt8((byte)((byte)hashFunction << 4));
this.hashFunction = hashFunction;
// CA Name
this.name = authorityName;
cr.AddUInt8((byte)(authorityName.Length))
.AddUInt8Array(Encoding.ASCII.GetBytes(authorityName));
// public key
rsa = RSA.Create();// new RSACryptoServiceProvider(2048);
rsa.KeySize = 2048;
RSAParameters dRSAKey = rsa.ExportParameters(true);
cr.AddUInt8((byte)dRSAKey.Exponent.Length)
.AddUInt8Array(dRSAKey.Exponent)
.AddUInt16((ushort)dRSAKey.Modulus.Length)
.AddUInt8Array(dRSAKey.Modulus);
publicRawData = cr.ToArray();
privateRawData = DC.Merge(dRSAKey.D, dRSAKey.DP, dRSAKey.DQ, dRSAKey.InverseQ, dRSAKey.P, dRSAKey.Q);
}
public override bool Save(string filename, bool includePrivate = false)
{
try
{
if (includePrivate)
File.WriteAllBytes(filename, new BinaryList()
.AddUInt8((byte)CertificateType.CAPrivate)
.AddUInt8Array(publicRawData)
.AddUInt8Array(privateRawData)
.ToArray());
else
File.WriteAllBytes(filename, new BinaryList()
.AddUInt8((byte)CertificateType.CAPublic)
.AddUInt8Array(publicRawData).ToArray());
return true;
}
catch
{
return false;
}
}
public override byte[] Serialize(bool includePrivate = false)
{
if (includePrivate)
return new BinaryList()
.AddUInt8Array(publicRawData)
.AddUInt8Array(privateRawData)
.ToArray();
else
return publicRawData;
}
}

221
Esiur/Security/Authority/Certificate.cs
View File

@@ -1,221 +0,0 @@
/*
Copyright (c) 2019 - 2024 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using Esiur.Data;
using Esiur.Core;
using Esiur.Misc;
using Esiur.Security.Cryptography;
using Esiur.Security.Integrity;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public abstract class Certificate
{
protected DateTime issueDate, expireDate;
protected RSA rsa;
protected Aes aes;
protected byte[] publicRawData;
protected byte[] privateRawData;
protected ulong id;
protected HashFunctionType hashFunction;
public Certificate(ulong id, DateTime issueDate, DateTime expireDate, HashFunctionType hashFunction)
{
this.id = id;
this.issueDate = issueDate;
this.expireDate = expireDate;
this.hashFunction = hashFunction;
}
public ulong Id
{
get { return id; }
}
public AsymetricEncryptionAlgorithmType AsymetricEncryptionAlgorithm
{
get { return AsymetricEncryptionAlgorithmType.RSA; }
}
public byte[] AsymetricEncrypt(byte[] message)
{
return rsa.Encrypt(message, RSAEncryptionPadding.OaepSHA512);
}
public byte[] AsymetricEncrypt(byte[] message, uint offset, uint length)
{
if (message.Length != length)
return rsa.Encrypt(DC.Clip(message, offset, length), RSAEncryptionPadding.OaepSHA512);
else
return rsa.Encrypt(message, RSAEncryptionPadding.OaepSHA512);
}
public byte[] AsymetricDecrypt(byte[] message)
{
try
{
return rsa.Decrypt(message, RSAEncryptionPadding.OaepSHA512);
}
catch (Exception ex)
{
Global.Log("Certificate", LogType.Error, ex.ToString());
return null;
}
}
public byte[] AsymetricDecrypt(byte[] message, uint offset, uint length)
{
try
{
if (message.Length != length)
return rsa.Decrypt(DC.Clip(message, offset, length), RSAEncryptionPadding.OaepSHA512);
else
return rsa.Decrypt(message, RSAEncryptionPadding.OaepSHA512);
}
catch (Exception ex)
{
Global.Log("Certificate", LogType.Error, ex.ToString());
return null;
}
}
public byte[] SymetricEncrypt(byte[] message, uint offset, uint length)
{
byte[] rt = null;
using (var ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
cs.Write(message, (int)offset, (int)length);
rt = ms.ToArray();
}
return rt;
}
public byte[] SymetricEncrypt(byte[] message)
{
return SymetricEncrypt(message, 0, (uint)message.Length);
}
public byte[] SymetricDecrypt(byte[] message, uint offset, uint length)
{
byte[] rt = null;
using (var ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
cs.Write(message, (int)offset, (int)length);
rt = ms.ToArray();
}
return rt;
}
public byte[] SymetricDecrypt(byte[] message)
{
return SymetricDecrypt(message, 0, (uint)message.Length);
}
public byte[] Sign(byte[] message)
{
return Sign(message, 0, (uint)message.Length);
}
public byte[] Sign(byte[] message, uint offset, uint length)
{
if (hashFunction == HashFunctionType.SHA1)
return rsa.SignData(message, (int)offset, (int)length, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
else if (hashFunction == HashFunctionType.MD5)
return rsa.SignData(message, (int)offset, (int)length, HashAlgorithmName.MD5, RSASignaturePadding.Pkcs1);
else if (hashFunction == HashFunctionType.SHA256)
return rsa.SignData(message, (int)offset, (int)length, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
else if (hashFunction == HashFunctionType.SHA384)
return rsa.SignData(message, (int)offset, (int)length, HashAlgorithmName.SHA384, RSASignaturePadding.Pkcs1);
else if (hashFunction == HashFunctionType.SHA512)
return rsa.SignData(message, (int)offset, (int)length, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
return null;
}
public bool InitializeSymetricCipher(SymetricEncryptionAlgorithmType algorithm, int keyLength, byte[] key, byte[] iv)
{
if (algorithm == SymetricEncryptionAlgorithmType.AES)
{
if (keyLength == 0) // 128 bit
{
aes = Aes.Create();
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
aes.Key = key;
aes.IV = iv;
return true;
}
}
return false;
}
public abstract bool Save(string filename, bool includePrivate = false);
public abstract byte[] Serialize(bool includePrivate = false);
public static Certificate Load(string filename)
{
byte[] ar = File.ReadAllBytes(filename);
var t = (CertificateType)ar[0];
switch (t)
{
case CertificateType.CAPublic:
return new CACertificate(ar, 1, (uint)ar.Length - 1);
case CertificateType.CAPrivate:
return new CACertificate(ar, 1, (uint)ar.Length - 1, true);
case CertificateType.DomainPublic:
return new DomainCertificate(ar, 1, (uint)ar.Length - 1);
case CertificateType.DomainPrivate:
return new DomainCertificate(ar, 1, (uint)ar.Length - 1, true);
case CertificateType.UserPublic:
return new UserCertificate(ar, 1, (uint)ar.Length - 1);
case CertificateType.UserPrivate:
return new UserCertificate(ar, 1, (uint)ar.Length - 1, true);
}
return null;
}
}

41
Esiur/Security/Authority/CertificateType.cs
View File

@@ -1,41 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public enum CertificateType
{
CAPublic = 0,
CAPrivate,
DomainPublic,
DomainPrivate,
UserPublic,
UserPrivate
}

70
Esiur/Security/Authority/ClientAuthentication.cs
View File

@@ -1,70 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class ClientAuthentication : Authentication
{
/*
string username;
byte[] password;
string domain;
byte[] token;
UserCertificate certificate;
public string Username => username;
public byte[] Password => password;
//public string Domain => domain;
public byte[] Token => token;
public byte[] Nounce { get; set; }
*/
public ClientAuthentication()
: base(AuthenticationType.Client)
{
}
/*
public ClientAuthentication(byte[] token)
: base(AuthenticationType.Client)
{
this.token = token;
}
public ClientAuthentication(string username, byte[] password)
: base(AuthenticationType.Client)
{
this.username = username;
this.password = password;
//this.domain = domain;
}
*/
}

40
Esiur/Security/Authority/CoHostAuthentication.cs
View File

@@ -1,40 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class CoHostAuthentication : Authentication
{
public CoHostAuthentication()
: base(AuthenticationType.CoHost)
{
}
}

249
Esiur/Security/Authority/DomainCertificate.cs
View File

@@ -1,249 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using Esiur.Data;
using Esiur.Misc;
using Esiur.Security.Cryptography;
using Esiur.Security.Integrity;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class DomainCertificate : Certificate
{
uint ip;
byte[] ip6;
string domain;
//CACertificate ca;
string caName;
ulong caId;
byte[] signature;
string authorityName;
public string AuthorityName
{
get { return authorityName; }
}
public string Domain
{
get { return domain; }
}
public byte[] Signature
{
get { return signature; }
}
public uint IPAddress
{
get { return ip; }
}
public byte[] IPv6Address
{
get { return ip6; }
}
public DomainCertificate(byte[] data, uint offset, uint length, bool privateKeyIncluded = false)
: base(0, DateTime.MinValue, DateTime.MinValue, HashFunctionType.MD5)
{
var oOffset = offset;
this.id = DC.GetUInt64(data, offset, Endian.Little);
offset += 8;
// load IPs
this.ip = DC.GetUInt32(data, offset, Endian.Little);
offset += 4;
this.ip6 = DC.Clip(data, offset, 16);
offset += 16;
this.issueDate = DC.GetDateTime(data, offset, Endian.Little);
offset += 8;
this.expireDate = DC.GetDateTime(data, offset, Endian.Little);
offset += 8;
this.domain = Encoding.ASCII.GetString(data, (int)offset + 1, data[offset]);
offset += (uint)data[offset] + 1;
this.authorityName = (Encoding.ASCII.GetString(data, (int)offset + 1, data[offset]));
offset += (uint)data[offset] + 1;
caId = DC.GetUInt64(data, offset, Endian.Little);
offset += 8;
var aea = (AsymetricEncryptionAlgorithmType)(data[offset] >> 5);
if (aea == AsymetricEncryptionAlgorithmType.RSA)
{
var key = new RSAParameters();
uint exponentLength = (uint)data[offset++] & 0x1F;
key.Exponent = DC.Clip(data, offset, exponentLength);
offset += exponentLength;
uint keySize = DC.GetUInt16(data, offset, Endian.Little);
offset += 2;
key.Modulus = DC.Clip(data, offset, keySize);
offset += keySize;
// copy cert data
publicRawData = new byte[offset - oOffset];
Buffer.BlockCopy(data, (int)oOffset, publicRawData, 0, publicRawData.Length);
if (privateKeyIncluded)
{
uint privateKeyLength = (keySize * 3) + (keySize / 2);
privateRawData = DC.Clip(data, offset, privateKeyLength);
uint halfKeySize = keySize / 2;
key.D = DC.Clip(data, offset, keySize);
offset += keySize;
key.DP = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.DQ = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.InverseQ = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.P = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
key.Q = DC.Clip(data, offset, halfKeySize);
offset += halfKeySize;
}
// setup rsa
rsa = RSA.Create();// new RSACryptoServiceProvider();
rsa.ImportParameters(key);
this.signature = DC.Clip(data, offset, length - (offset - oOffset));
}
}
public DomainCertificate(ulong id, string domain, CACertificate authority, DateTime issueDate,
DateTime expireDate, HashFunctionType hashFunction = HashFunctionType.SHA1, uint ip = 0, byte[] ip6 = null)
: base(id, issueDate, expireDate, hashFunction)
{
// assign type
var cr = new BinaryList();
// id
cr.AddUInt64(id);
// ip
this.ip = ip;
this.ip6 = ip6;
cr.AddUInt32(ip);
if (ip6?.Length == 16)
cr.AddUInt8Array(ip6);
else
cr.AddUInt8Array(new byte[16]);
cr.AddDateTime(issueDate)
.AddDateTime(expireDate);
// domain
this.domain = domain;
cr.AddUInt8((byte)(domain.Length))
.AddUInt8Array(Encoding.ASCII.GetBytes(domain));
// CA
this.caName = authority.Name;
cr.AddUInt8((byte)(authority.Name.Length))
.AddUInt8Array(Encoding.ASCII.GetBytes(authority.Name));
this.authorityName = authority.Name;
// CA Index
//co.KeyIndex = authority.KeyIndex;
this.caId = authority.Id;
cr.AddUInt64(caId);
// public key
rsa = RSA.Create();// new RSACryptoServiceProvider(2048);
rsa.KeySize = 2048;
RSAParameters dRSAKey = rsa.ExportParameters(true);
cr.AddUInt8((byte)dRSAKey.Exponent.Length)
.AddUInt8Array(dRSAKey.Exponent)
.AddUInt16((ushort)dRSAKey.Modulus.Length)
.AddUInt8Array(dRSAKey.Modulus);
publicRawData = cr.ToArray();
// private key
this.privateRawData = DC.Merge(dRSAKey.D, dRSAKey.DP, dRSAKey.DQ, dRSAKey.InverseQ, dRSAKey.P, dRSAKey.Q);
this.signature = authority.Sign(publicRawData);
}
public override bool Save(string filename, bool includePrivate = false)
{
try
{
if (includePrivate)
File.WriteAllBytes(filename, DC.Merge(new byte[] { (byte)CertificateType.DomainPrivate }, publicRawData, signature, privateRawData));
else
File.WriteAllBytes(filename, DC.Merge(new byte[] { (byte)CertificateType.DomainPublic }, publicRawData, signature));
return true;
}
catch
{
return false;
}
}
public override byte[] Serialize(bool includePrivate = false)
{
if (includePrivate)
return DC.Merge(publicRawData, signature, privateRawData);
else
return DC.Merge(publicRawData, signature);
}
}

41
Esiur/Security/Authority/HostAuthentication.cs
View File

@@ -1,41 +0,0 @@
/*
Copyright (c) 2017 Ahmed Kh. Zamil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Esiur.Security.Authority;
public class HostAuthentication : Authentication
{
public HostAuthentication()
: base(AuthenticationType.Host)
{
}
}

18
Esiur/Security/Authority/IAuthenticationHandler.cs Normal file
View File

@@ -0,0 +1,18 @@
using Esiur.Net.Packets;
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Authority
{
public interface IAuthenticationHandler
{
public AuthenticationResult Initialize(Session session);
public AuthenticationResult Process(object handshakePayload);
public void Terminate(Session session);
public void Update(Session session, object authData);
}
}

13
Esiur/Security/Authority/IAuthenticationInitiator.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Authority
{
public interface IAuthenticationInitiator
{
public AuthenticationResult Initiate(Session session);
public AuthenticationResult Process(object handshakePayload);
}
}

12
Esiur/Security/Authority/IAuthenticationResponder.cs Normal file
View File

@@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Authority
{
public interface IAuthenticationResponder
{
public AuthenticationResult Process(Session session);
}
}

17
Esiur/Security/Authority/Session.cs
View File

@@ -31,7 +31,6 @@ using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using Esiur.Security.Cryptography; using Esiur.Security.Cryptography;
using static System.Collections.Specialized.BitVector32;
using Esiur.Net.Packets; using Esiur.Net.Packets;
namespace Esiur.Security.Authority; namespace Esiur.Security.Authority;
@@ -44,21 +43,21 @@ public class Session
public IKeyExchanger KeyExchanger { get; set; } = null; //public IKeyExchanger KeyExchanger { get; set; } = null;
public ISymetricCipher SymetricCipher { get; set; } = null; public ISymetricCipher SymetricCipher { get; set; } = null;
public Map<EpAuthPacketHeader, object> LocalHeaders { get; set; } = new Map<EpAuthPacketHeader, object>(); public Map<EpAuthPacketHeader, object> LocalHeaders { get; set; } = new Map<EpAuthPacketHeader, object>();
public Map<EpAuthPacketHeader, object> RemoteHeaders { get; set; } = new Map<EpAuthPacketHeader, object>(); public Map<EpAuthPacketHeader, object> RemoteHeaders { get; set; } = new Map<EpAuthPacketHeader, object>();
public AuthenticationMethod LocalMethod { get; set; } //public AuthenticationMethod AuthenticationMethod { get; set; }
public AuthenticationMethod RemoteMethod { get; set; } //public AuthenticationMethod RemoteMethod { get; set; }
public AuthenticationType AuthenticationType { get; set; } public AuthenticationMode AuthenticationMode { get; set; }
public EncryptionMode EncryptionMode { get; set; }
public IAuthenticationHandler AuthenticationHandler { get; set; }
//public IAuthenticationHandler AuthenticationResponder { get; set; }
public string AuthorizedAccount { get; set; } public string AuthorizedIdentity { get; set; }
} }

14
Esiur/Security/Cryptography/EncryptionMode.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Esiur.Security.Cryptography
{
public enum EncryptionMode
{
None,
EncryptWithSessionKey,
EncryptWithSessionKeyAndAddress,
}
}

6
Tests/Distribution/Program.cs
View File

@@ -24,7 +24,7 @@ SOFTWARE.
using Esiur.Data; using Esiur.Data;
using Esiur.Core; using Esiur.Core;
using Esiur.Net.HTTP; using Esiur.Net.Http;
using Esiur.Net.Sockets; using Esiur.Net.Sockets;
using Esiur.Resource; using Esiur.Resource;
using Esiur.Security.Permissions; using Esiur.Security.Permissions;
@@ -148,7 +148,7 @@ class Program
var server = await wh.Put("sys/server", new EpServer() { Membership = membership }); var server = await wh.Put("sys/server", new EpServer() { Membership = membership });
var web = await wh.Put("sys/web", new HTTPServer() { Port = 8088 }); var web = await wh.Put("sys/web", new HttpServer() { Port = 8088 });
var service = await wh.Put("sys/service", new MyService()); var service = await wh.Put("sys/service", new MyService());
var res1 = await wh.Put("sys/service/r1", new MyResource() { Description = "Testing 1", CategoryId = 10 }); var res1 = await wh.Put("sys/service/r1", new MyResource() { Description = "Testing 1", CategoryId = 10 });
@@ -177,7 +177,7 @@ class Program
// sender.Send("Not found"); // sender.Send("Not found");
//}); //});
web.MapGet("/", (HTTPConnection sender) => web.MapGet("/", (HttpConnection sender) =>
{ {
sender.Send("Hello"); sender.Send("Hello");
}); });