public static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("[!] Usage: SILENTTRINITY.exe <URL> [<STAGE_URL>]");
Environment.Exit(1);
}
Guid GUID = Guid.NewGuid();
Uri URL = new Uri(new Uri(args[0]), GUID.ToString());
#if DEBUG
Console.WriteLine("[+] URL: {0}", URL);
#endif
try
{
#if DEBUG
Console.WriteLine("[+] Trying to get the stage...");
#endif
Stage = ZipStorer.Open(Internals.DownloadStage(URL),
FileAccess.ReadWrite,
true);
}
catch
{
#if DEBUG
Console.WriteLine("\n\n[!] ERROR: Unable to get the stage.");
#endif
Environment.Exit(-1);
}
#if DEBUG
Console.WriteLine("[+] Running the Engine...");
#endif
Engines.IronPython.Run(URL, GUID, Stage); //Magic!!
}
internal ObjectHolder(Internals.Context context, Type type, object key) {
this.context = context;
this.type = type;
this.selectSP = null;
// DBNull Bug-Fix by Gerrod Thomas (http://www.Gerrod.com)
this.key = (key is System.DBNull ? null : key);
}
public static void InstallRunGNatives(this Lua env)
{
env["_VERSION"] = "G#.NET v" + RunGInfo.VERSION;
env["natives"] = new Internals();
env.InstallFunction("read");
env.InstallFunction("clear");
env.InstallFunction("pause");
env.InstallFunction("print", "...");
env.InstallFunction("write", "...");
env.InstallFunction("log", "...");
env.InstallFunction("sleep", "time");
env.InstallFunction("beep", "freq, dur");
env.DoString(
@"function try(func,catch)
local r = {pcall(func)}
if not r[1] then catch(unpack(r)) end
end
function switch(t)
t.case = function (self,x)
local f=self[x] or self.default
if f then
if type(f)==""function"" then
f(x,self)
else
error(""case ""..tostring(x).."" not a function"")
end
end
end
return t
end"
);
}
internal ObjectHolder(Internals.Context context, SelectProcedure selectSP) {
this.context = context;
this.type = selectSP.ObjectType;
this.selectSP = selectSP;
// DBNull Bug-Fix by Gerrod Thomas (http://www.Gerrod.com)
this.key = (selectSP.ParameterValue(0) is System.DBNull ? null : selectSP.ParameterValue(0));
}
// SetUnmanagedStructures
//
// Fills in overlapped Structures used in an async overlapped Winsock call.
// These calls are outside the runtime and are unmanaged code, so we need
// to prepare specific structures and ints that lie in unmanaged memory
// since the overlapped calls may complete asynchronously.
internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, Internals.SocketAddress socketAddress, SocketFlags socketFlags)
{
_messageBuffer = new byte[s_wsaMsgSize];
_wsaBufferArray = new byte[s_wsaBufferSize];
bool ipv4, ipv6;
Socket.GetIPProtocolInformation(((Socket)AsyncObject).AddressFamily, socketAddress, out ipv4, out ipv6);
// Prepare control buffer.
if (ipv4)
{
_controlBuffer = new byte[s_controlDataSize];
}
else if (ipv6)
{
_controlBuffer = new byte[s_controlDataIPv6Size];
}
// Pin buffers.
object[] objectsToPin = new object[(_controlBuffer != null) ? 5 : 4];
objectsToPin[0] = buffer;
objectsToPin[1] = _messageBuffer;
objectsToPin[2] = _wsaBufferArray;
// Prepare socketaddress buffer.
_socketAddress = socketAddress;
_socketAddress.CopyAddressSizeIntoBuffer();
objectsToPin[3] = _socketAddress.Buffer;
if (_controlBuffer != null)
{
objectsToPin[4] = _controlBuffer;
}
base.SetUnmanagedStructures(objectsToPin);
// Prepare data buffer.
_wsaBuffer = (WSABuffer*)Marshal.UnsafeAddrOfPinnedArrayElement(_wsaBufferArray, 0);
_wsaBuffer->Length = size;
_wsaBuffer->Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);
// Setup structure.
_message = (Interop.Winsock.WSAMsg*)Marshal.UnsafeAddrOfPinnedArrayElement(_messageBuffer, 0);
_message->socketAddress = Marshal.UnsafeAddrOfPinnedArrayElement(_socketAddress.Buffer, 0);
_message->addressLength = (uint)_socketAddress.Size;
_message->buffers = Marshal.UnsafeAddrOfPinnedArrayElement(_wsaBufferArray, 0);
_message->count = 1;
if (_controlBuffer != null)
{
_message->controlBuffer.Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(_controlBuffer, 0);
_message->controlBuffer.Length = _controlBuffer.Length;
}
_message->flags = socketFlags;
}
private Internals CreateInternals()
{
var internals =
new Internals(new Remoting(_system, this), _system.Serialization,
new RemoteSystemDaemon(_system, RootPath / "remote", RootGuardian, _remotingTerminator, _log));
_local.RegisterExtraName("remote", internals.RemoteDaemon);
return(internals);
}
public void ReportUpdated(String name)
{
if (Destroyed)
{
return;
}
Internals.DispatchUpdated(this, name);
}
public SemaphoreW(int spinCountParam)
{
Debug.Assert(spinCountParam >= 0);
internals = default;
spinCount = spinCountParam;
lifoSemaphore = new Semaphore(0, int.MaxValue);
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.Unknown0x00 = context.Reader.ReadByte();
if (Internal.Unknown0x00 != 2)
{
context.Warnings.Add("FmatAttribute.Unknown0x00 has unexpected value of " + Internal.Unknown0x00);
}
Internal.Unknown0x01 = context.Reader.ReadByte();
if (Internal.Unknown0x01 != 0x00 && Internal.Unknown0x01 != 0x02 && Internal.Unknown0x01 != 0x04
&& Internal.Unknown0x01 != 0x12)
{
context.Warnings.Add("FmatAttribute.Unknown0x01 has unexpected value of " + Internal.Unknown0x01);
}
Internal.Unknown0x02 = context.Reader.ReadByte();
if (Internal.Unknown0x02 != 0x00 && Internal.Unknown0x02 != 0x10 && Internal.Unknown0x02 != 0x12
&& Internal.Unknown0x02 != 0x5A)
{
context.Warnings.Add("FmatAttribute.Unknown0x02 has unexpected value of " + Internal.Unknown0x02);
}
Internal.Unknown0x03 = context.Reader.ReadByte();
Internal.Unknown0x04 = context.Reader.ReadSByte();
Internal.Unknown0x05 = context.Reader.ReadByte();
Internal.Unknown0x06 = context.Reader.ReadUInt16();
Internal.Unknown0x08 = context.Reader.ReadUInt32();
if (Internal.Unknown0x08 != 0x80000000)
{
context.Warnings.Add("FmatAttribute.Unknown0x08 has unexpected value of " + Internal.Unknown0x08);
}
Internal.Unknown0x0C = context.Reader.ReadUInt32();
if (Internal.Unknown0x0C != 0)
{
context.Warnings.Add("FmatAttribute.Unknown0x0C has unexpected value of " + Internal.Unknown0x0C);
}
Internal.NameOffset = context.Reader.ReadBfresNameOffset();
Name = Internal.NameOffset.Name;
Internal.Index = context.Reader.ReadByte();
Internal.Unknown0x15 = context.Reader.ReadByte();
if (Internal.Unknown0x15 != 0)
{
context.Warnings.Add("FmatAttribute.Unknown0x15 has unexpected value of " + Internal.Unknown0x15);
}
Internal.Unknown0x16 = context.Reader.ReadUInt16();
if (Internal.Unknown0x16 != 0)
{
context.Warnings.Add("FmatAttribute.Unknown0x16 has unexpected value of " + Internal.Unknown0x16);
}
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.NameOffset = context.Reader.ReadBfresNameOffset();
Name = Internal.NameOffset.Name;
Internal.Unknown0x04 = context.Reader.ReadUInt16();
Internal.Unknown0x06 = context.Reader.ReadUInt16();
Value = context.Reader.ReadSingle();
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.NameOffset = context.Reader.ReadBfresNameOffset();
Name = Internal.NameOffset.Name;
Internal.TextureOffset = context.Reader.ReadBfresOffset();
// Referenced texture is linked after loading and mapping the raw data.
}
private static System.Net.SocketAddress GetNetSocketAddress(Internals.SocketAddress address)
{
var result = new System.Net.SocketAddress(address.Family, address.Size);
for (int index = 0; index < address.Size; index++)
{
result[index] = address[index];
}
return result;
}
static Assembly ResolveEventHandler(object sender, ResolveEventArgs args)
{
string dllName = Internals.GetDLLName(args.Name);
byte[] bytes = Internals.GetResourceInZip(Stage, dllName) ??
File.ReadAllBytes(RuntimeEnvironment.GetRuntimeDirectory() + dllName);
#if DEBUG
Console.WriteLine("\t[+] '{0}' loaded", dllName);
#endif
return(Assembly.Load(bytes));
}
public SemaphoreW(int initialSignalCount, int spinCountParam)
{
Debug.Assert(initialSignalCount >= 0);
Debug.Assert(spinCountParam >= 0);
internals = default;
internals._counts.SignalCount = (uint)initialSignalCount;
spinCount = spinCountParam;
lifoSemaphore = new Semaphore(0, int.MaxValue);
}
/// <summary>
/// Creates instance of adapter.
/// </summary>
/// <param name="dataContext">Data context instance.</param>
/// <param name="expression">Query expression.</param>
public LinqToDBForEFQueryProvider(IDataContext dataContext, Expression expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var dataContext1 = dataContext ?? throw new ArgumentNullException(nameof(dataContext));
QueryProvider = (IQueryProviderAsync)Internals.CreateExpressionQueryInstance <T>(dataContext1, expression);
QueryProviderAsQueryable = (IQueryable <T>)QueryProvider;
}
public void CreatingQuery([IncludeDataSources(TestProvName.AllSQLite)] string context)
{
using (var db = GetDataContext(context))
using (var table = db.CreateLocalTable <SampleClass>())
{
var queryable = table.Where(t => t.Id == 1);
var newQueryable = Internals.CreateExpressionQueryInstance <SampleClass>(db, queryable.Expression);
newQueryable.ToArray();
}
}
internal ObjectReader(Internals.Context context, SelectProcedure selectProcedure, bool firstLevel) {
this.context = context;
this.firstLevel = firstLevel;
this.objectType = selectProcedure.ObjectType;
this.pageIndex = 1;
this.hasEvents = context.Mappings[this.objectType.ToString()].HasEvents;
this.selectProcedure = selectProcedure;
this.data = context.Connection.GetDataReader(this.objectType, CommandInfo.Select, out this.command, selectProcedure.ProcedureName, selectProcedure.parameters);
this.firstRead = true;
if (this.data != null) this.hasObjects = this.data.Read();
if (!this.hasObjects) this.Close();
}
// Jeff Lanning ([email protected]): Added for OPath support. internal ObjectReader(Internals.Context context, CompiledQuery query, bool firstLevel, object[] parameters) { this.context = context; this.firstLevel = firstLevel; this.objectType = query.ObjectType; this.pageIndex = 1; this.hasEvents = context.Mappings[this.objectType].HasEvents; this.data = context.Connection.GetDataReader(this.objectType, CommandInfo.Select, query, parameters); this.firstRead = true; if (this.data != null) this.hasObjects = this.data.Read(); if (!this.hasObjects) this.Close(); }
public static EndPoint Create(this EndPoint thisObj, Internals.SocketAddress socketAddress)
{
if (socketAddress.Family != thisObj.AddressFamily)
{
throw new ArgumentException(SR.Format(SR.net_InvalidAddressFamily, socketAddress.Family.ToString(), thisObj.GetType().FullName, thisObj.AddressFamily.ToString()), "socketAddress");
}
if (socketAddress.Size < 8)
{
throw new ArgumentException(SR.Format(SR.net_InvalidSocketAddressSize, socketAddress.GetType().FullName, thisObj.GetType().FullName), "socketAddress");
}
return socketAddress.GetIPEndPoint();
}
public DefaultServerPagerProcessor(
TagHelperContext context,
TagHelperOutput output,
PagerTagHelper tag,
Internals.PagerOptions options,
ContextualizedHelpers helpers
)
{
this.context = context;
this.output = output;
this.tag = tag;
this.options = options;
this.helpers = helpers;
}
public void AddDynamicWebPart(
WebPart webPart,
Microsoft.Web.Preview.UI.Controls.WebParts.WebPartZone webPartZone,
int zoneIndex, bool isShared)
{
if (!this.WebParts.Contains(webPart))
{
Internals.SetZoneID(webPart, webPartZone.ID);
Internals.SetIsShared(webPart, isShared);
Internals.SetZoneIndex(webPart, zoneIndex);
Internals.AddWebPart(webPart);
this.SetPersonalizationDirty();
}
}
public void Generate(Transform parentTransform, float targetY, int speed = 5)
{
var position = parentTransform.position;
position.y += targetY;
Internals.GenerateTile(dirtLeft, parentTransform, position, speed);
position.x += 1;
Internals.GenerateTile(dirtRight, parentTransform, position, speed);
position.x += 1.5f;
Internals.GenerateTile(platform, parentTransform, position, speed);
position.x += 1.5f;
Internals.GenerateTile(dirtLeft, parentTransform, position, speed);
position.x += 1;
Internals.GenerateTile(dirtRight, parentTransform, position, speed);
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
// Read magic bytes.
if (context.Reader.ReadString(4) != "FSKL")
{
throw new BfresException("FsklSkeleton identifier invalid");
}
Internal.Unknown0x04 = context.Reader.ReadUInt16();
if (Internal.Unknown0x04 != 0)
{
context.Warnings.Add("FsklSkeleton.Unknown0x04 has unexpected value of " + Internal.Unknown0x04);
}
Internal.Unknown0x06 = context.Reader.ReadUInt16();
if (Internal.Unknown0x06 != 0x1100 && Internal.Unknown0x06 != 0x1200)
{
context.Warnings.Add("FsklSkeleton.Unknown0x06 has unexpected value of " + Internal.Unknown0x06);
}
Internal.BoneCount = context.Reader.ReadUInt16();
Internal.InverseIndexCount = context.Reader.ReadUInt16();
Internal.ExtraIndexCount = context.Reader.ReadUInt16();
Internal.Unknown0x0E = context.Reader.ReadUInt16();
if (Internal.Unknown0x0E != 0)
{
context.Warnings.Add("FsklSkeleton.Unknown0x0E has unexpected value of " + Internal.Unknown0x0E);
}
Internal.BoneIndexGroupOffset = context.Reader.ReadBfresOffset();
Internal.BoneArrayOffset = context.Reader.ReadBfresOffset();
Internal.InverseIndexArrayOffset = context.Reader.ReadBfresOffset();
Internal.InverseMatrixArrayOffset = context.Reader.ReadBfresOffset();
if (context.Reader.ReadUInt32() != 0)
{
context.Warnings.Add("FsklSkeleton padding not empty");
}
// Restore the position after the header, to allow consecutive header reads for the parent.
using (context.Reader.TemporarySeek())
{
LoadBones(context);
}
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.Unknown0x00 = context.Reader.ReadUInt32();
Internal.Size = context.Reader.ReadUInt32();
Internal.Unknown0x08 = context.Reader.ReadUInt32();
Internal.Unknown0x0C = context.Reader.ReadUInt16();
Internal.Unknown0x0E = context.Reader.ReadUInt16();
Internal.Unknown0x10 = context.Reader.ReadUInt32();
Internal.DataOffset = context.Reader.ReadBfresOffset();
// Restore the position after the header, to allow consecutive header reads for the parent.
using (context.Reader.TemporarySeek())
{
LoadData(context);
}
}
static bool InitializeInternal()
{
var prev = LinqExtensions.ProcessSourceQueryable;
InitializeMapping();
var instantiator = MemberHelper.MethodOf(() => Internals.CreateExpressionQueryInstance <int>(null, null))
.GetGenericMethodDefinition();
LinqExtensions.ProcessSourceQueryable = queryable =>
{
// our Provider - nothing to do
if (queryable.Provider is IQueryProviderAsync)
{
return(queryable);
}
var context = Implementation.GetCurrentContext(queryable);
if (context == null)
{
throw new LinqToDBForEFToolsException("Can not evaluate current context from query");
}
var dc = CreateLinqToDbContext(context);
var newExpression = queryable.Expression;
var result = (IQueryable)instantiator.MakeGenericMethod(queryable.ElementType)
.Invoke(null, new object[] { dc, newExpression });
if (prev != null)
{
result = prev(result);
}
return(result);
};
LinqExtensions.ExtensionsAdapter = new LinqToDBExtensionsAdapter();
// Set linq2db to allow multiple queries by default
Common.Configuration.Linq.AllowMultipleQuery = true;
return(true);
}
/// <inheritdoc/>
public virtual void Init(ActorSystemImpl system)
{
_system = system;
_local.Init(system);
_remotingTerminator =
_system.SystemActorOf(
RemoteSettings.ConfigureDispatcher(Props.Create(() => new RemotingTerminator(_local.SystemGuardian))),
"remoting-terminator");
_internals = CreateInternals();
_remotingTerminator.Tell(RemoteInternals);
Transport.Start();
_remoteWatcher = CreateRemoteWatcher(system);
_remoteDeploymentWatcher = CreateRemoteDeploymentWatcher(system);
}
internal ObjectReader(Internals.Context context, ObjectQuery objectQuery, bool firstLevel) {
this.context = context;
this.firstLevel = firstLevel;
this.objectType = objectQuery.ObjectType;
this.pageIndex = objectQuery.PageIndex;
this.hasEvents = context.Mappings[this.objectType.ToString()].HasEvents;
Internals.Commands commands = context.Mappings.Commands(this.objectType.ToString());
if (objectQuery.PageSize > 0 && !objectQuery.SkipCounts) {
string selectCount = commands.RecordCount(objectQuery.WhereClause);
this.totalCount = int.Parse(context.Connection.GetScalarValue(this.objectType, CommandInfo.GetCount, selectCount).ToString());
double pages = (double) (1 + (this.totalCount - 1) / objectQuery.PageSize);
this.pageCount = int.Parse(Math.Floor(pages).ToString());
}
this.data = context.Connection.GetDataReader(this.objectType, CommandInfo.Select, commands.Select(objectQuery));
this.firstRead = true;
if (this.data != null) this.hasObjects = this.data.Read();
if (!this.hasObjects) this.Close();
}
public void Generate(Transform parentTransform, float targetY, int speed = 5)
{
var position = parentTransform.position;
position.y += targetY;
Internals.GenerateTile(platformL, parentTransform, position, speed);
position.x += 1;
Internals.GenerateTile(platformR, parentTransform, position, speed);
position.y += 1;
if (Random.Range(0f, 1f) < victoryProbability)
{
Internals.GenerateTile(victory, parentTransform, position, speed);
}
else
{
Internals.GenerateTile(coin, parentTransform, position, speed);
}
}
async Task <TResult> IQueryProviderAsync.ExecuteAsync <TResult>(Expression expression, CancellationToken token)
{
var entity = await LinqToDBQuery.ExecuteAsync <TResult>(expression, token);
if (entity is T tEntity)
{
var db = this.GetDataContext <IDataContext>();
var resultingQuery = Internals.CreateExpressionQueryInstance <TResult>(db, expression);
var queryToPass = from x in this
where
x == resultingQuery
select x;
_rootAccessor.LoadMap(new List <T> {
tEntity
}, queryToPass, _builder);
}
return(entity);
}
static Assembly STResolveEventHandler(object sender, ResolveEventArgs args)
{
byte[] bytes = null;
string DllName = Internals.GetDLLName(args.Name);
bytes = Internals.GetResourceInZip(Stage, DllName);
if (bytes == null)
{
bytes = File.ReadAllBytes(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory() + DllName);
}
Assembly asm = Assembly.Load(bytes);
#if DEBUG
Console.WriteLine("'{0}' loaded", asm.FullName);
#endif
return(asm);
}
public static EndPoint Create(this EndPoint thisObj, Internals.SocketAddress socketAddress)
{
AddressFamily family = socketAddress.Family;
if (family != thisObj.AddressFamily)
{
throw new ArgumentException(SR.Format(SR.net_InvalidAddressFamily, family.ToString(), thisObj.GetType().FullName, thisObj.AddressFamily.ToString()), nameof(socketAddress));
}
if (family == AddressFamily.InterNetwork || family == AddressFamily.InterNetworkV6)
{
if (socketAddress.Size < 8)
{
throw new ArgumentException(SR.Format(SR.net_InvalidSocketAddressSize, socketAddress.GetType().FullName, thisObj.GetType().FullName), nameof(socketAddress));
}
return socketAddress.GetIPEndPoint();
}
System.Net.SocketAddress address = GetNetSocketAddress(socketAddress);
return thisObj.Create(address);
}
public override void Destroy()
{
if (!Destroyed)
{
if (this != Root)
{
base.Destroy();
foreach (Entity ent in new List <Entity>(Childs))
{
ent.Destroy();
}
foreach (Component comp in new List <Component>(ChildComponents))
{
comp.Destroy();
}
Internals.DispatchDeleted(this);
}
}
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
// Read magic bytes.
if (context.Reader.ReadString(4) != "FVTX")
{
throw new BfresException("FvtxVertexData identifier invalid");
}
Internal.AttributeCount = context.Reader.ReadByte();
Internal.BufferCount = context.Reader.ReadByte();
Internal.Index = context.Reader.ReadUInt16();
Internal.NumberOfElements = context.Reader.ReadUInt32();
Internal.Unknown0x0C = context.Reader.ReadUInt32();
if (Internal.Unknown0x0C != 0x00000000 && Internal.Unknown0x0C != 0x01000000
&& Internal.Unknown0x0C != 0x02000000 && Internal.Unknown0x0C != 0x03000000
&& Internal.Unknown0x0C != 0x04000000)
{
context.Warnings.Add("FvtxVertexData.Unknown0x0C has unexpected value of " + Internal.Unknown0x0C);
}
Internal.AttributeArrayOffset = context.Reader.ReadBfresOffset();
Internal.AttributeIndexGroupOffset = context.Reader.ReadBfresOffset();
Internal.BufferArrayOffset = context.Reader.ReadBfresOffset();
if (context.Reader.ReadUInt32() != 0)
{
context.Warnings.Add("FvtxVertexData padding not empty");
}
// Restore the position after the header, to allow consecutive header reads for the parent.
using (context.Reader.TemporarySeek())
{
LoadData(context);
LoadAttributes(context);
}
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.NameOffset = context.Reader.ReadBfresNameOffset();
Name = Internal.NameOffset.Name;
Internal.Unknown0x04 = context.Reader.ReadUInt16();
if (Internal.Unknown0x04 != 1)
{
context.Warnings.Add("FmatMaterial.Unknown0x04 has unexpected value of " + Internal.Unknown0x04);
}
Internal.Unknown0x06 = context.Reader.ReadByte();
Internal.Unknown0x07 = context.Reader.ReadByte();
if (Internal.Unknown0x07 != 0)
{
context.Warnings.Add("FmatMaterial.Unknown0x07 has unexpected value of " + Internal.Unknown0x07);
}
Value = context.Reader.ReadUInt32();
}
// SetUnmanagedStructures
//
// Fills in overlapped structures used in an async overlapped Winsock call.
// These calls are outside the runtime and are unmanaged code, so we need
// to prepare specific structures and ints that lie in unmanaged memory
// since the overlapped calls may complete asynchronously.
internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, Internals.SocketAddress socketAddress, bool pinSocketAddress)
{
// Fill in Buffer Array structure that will be used for our send/recv Buffer
_socketAddress = socketAddress;
if (pinSocketAddress && _socketAddress != null)
{
object[] objectsToPin = null;
objectsToPin = new object[2];
objectsToPin[0] = buffer;
_socketAddress.CopyAddressSizeIntoBuffer();
objectsToPin[1] = _socketAddress.Buffer;
base.SetUnmanagedStructures(objectsToPin);
}
else
{
base.SetUnmanagedStructures(buffer);
}
_singleBuffer.Length = size;
_singleBuffer.Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.Unknown0x00 = context.Reader.ReadUInt32();
if (Internal.Unknown0x00 != 4)
{
context.Warnings.Add("FshpLodModel.Unknown0x00 has unexpected value of " + Internal.Unknown0x00);
}
Internal.Unknown0x04 = context.Reader.ReadUInt32();
if (Internal.Unknown0x04 != 4)
{
context.Warnings.Add("FshpLodModel.Unknown0x04 has unexpected value of " + Internal.Unknown0x04);
}
TotalPointCount = context.Reader.ReadUInt32();
Internal.VisibilityGroupCount = context.Reader.ReadUInt16();
Internal.Unknown0x0E = context.Reader.ReadUInt16();
if (Internal.Unknown0x0E != 0)
{
context.Warnings.Add("FshpLodModel.Unknown0x0E has unexpected value of " + Internal.Unknown0x0E);
}
Internal.VisibilityGroupOffset = context.Reader.ReadBfresOffset();
Internal.IndexBufferOffset = context.Reader.ReadBfresOffset();
SkipElements = context.Reader.ReadUInt32();
// Restore the position after the header, to allow consecutive header reads for the parent.
using (context.Reader.TemporarySeek())
{
LoadVisibilityGroup(context);
LoadIndexBuffer(context);
}
}
internal static void GetIPProtocolInformation(AddressFamily addressFamily, Internals.SocketAddress socketAddress, out bool isIPv4, out bool isIPv6)
{
bool isIPv4MappedToIPv6 = socketAddress.Family == AddressFamily.InterNetworkV6 && socketAddress.GetIPAddress().IsIPv4MappedToIPv6;
isIPv4 = addressFamily == AddressFamily.InterNetwork || isIPv4MappedToIPv6; // DualMode
isIPv6 = addressFamily == AddressFamily.InterNetworkV6;
}
private void DoBeginReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint endPointSnapshot, Internals.SocketAddress socketAddress, OverlappedAsyncResult asyncResult)
{
EndPoint oldEndPoint = _rightEndPoint;
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::DoBeginReceiveFrom() size:" + size.ToString());
// Guarantee to call CheckAsyncCallOverlappedResult if we call SetUnamangedStructures with a cache in order to
// avoid a Socket leak in case of error.
SocketError errorCode = SocketError.SocketError;
try
{
// Save a copy of the original EndPoint in the asyncResult.
asyncResult.SocketAddressOriginal = IPEndPointExtensions.Serialize(endPointSnapshot);
if (_rightEndPoint == null)
{
_rightEndPoint = endPointSnapshot;
}
errorCode = SocketPal.ReceiveFromAsync(_handle, buffer, offset, size, socketFlags, socketAddress, asyncResult);
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::DoBeginReceiveFrom() Interop.Winsock.WSARecvFrom returns:" + errorCode.ToString() + " size:" + size.ToString() + " returning AsyncResult:" + Logging.HashString(asyncResult));
}
catch (ObjectDisposedException)
{
_rightEndPoint = oldEndPoint;
throw;
}
finally
{
errorCode = asyncResult.CheckAsyncCallOverlappedResult(errorCode);
}
// Throw an appropriate SocketException if the native call fails synchronously.
if (errorCode != SocketError.Success)
{
// Update the internal state of this socket according to the error before throwing.
_rightEndPoint = oldEndPoint;
SocketException socketException = new SocketException((int)errorCode);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "BeginReceiveFrom", socketException);
}
throw socketException;
}
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::DoBeginReceiveFrom() size:" + size.ToString() + " returning AsyncResult:" + Logging.HashString(asyncResult));
}
// ---- METHODS (PRIVATE) --------------------------------------------------------------------------------------
private void Load(BfresLoaderContext context)
{
Internal = new Internals();
Internal.Unknown0x00 = context.Reader.ReadUInt32();
if (Internal.Unknown0x00 >= 0x14)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x00 has unexpected value of "
+ Internal.Unknown0x00);
}
Internal.Unknown0x04 = context.Reader.ReadUInt16();
if (Internal.Unknown0x04 != 0x0028)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x04 has unexpected value of "
+ Internal.Unknown0x04);
}
Internal.Unknown0x06 = context.Reader.ReadUInt16();
if (Internal.Unknown0x06 != 0x0240 && Internal.Unknown0x06 != 0x0242 && Internal.Unknown0x06 != 0x0243)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x06 has unexpected value of "
+ Internal.Unknown0x06);
}
Internal.Unknown0x08 = context.Reader.ReadUInt32();
if (Internal.Unknown0x08 != 0x49749732 && Internal.Unknown0x08 != 0x49749736)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x08 has unexpected value of "
+ Internal.Unknown0x08);
}
Internal.Unknown0x0C = context.Reader.ReadUInt32();
if (Internal.Unknown0x0C > 0x0E)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x0C has unexpected value of "
+ Internal.Unknown0x0C);
}
Internal.Unknown0x10 = context.Reader.ReadSingle();
if (Internal.Unknown0x10 >= 1f)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x10 has unexpected value of "
+ Internal.Unknown0x10);
}
Internal.Unknown0x14 = context.Reader.ReadUInt16();
if (Internal.Unknown0x14 != 0x00CC)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x14 has unexpected value of "
+ Internal.Unknown0x14);
}
Internal.Unknown0x16 = context.Reader.ReadUInt16();
if (Internal.Unknown0x16 != 0x0000 && Internal.Unknown0x16 != 0x0100)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x16 has unexpected value of "
+ Internal.Unknown0x16);
}
Internal.Unknown0x18 = context.Reader.ReadUInt32();
if (Internal.Unknown0x18 != 0)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x18 has unexpected value of "
+ Internal.Unknown0x18);
}
Internal.Unknown0x1C = context.Reader.ReadUInt16();
if (Internal.Unknown0x1C != 0x2001)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x1C has unexpected value of "
+ Internal.Unknown0x1C);
}
Internal.Unknown0x1E = context.Reader.ReadByte();
if (Internal.Unknown0x1E != 1 && Internal.Unknown0x1E != 0x05)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x1E has unexpected value of "
+ Internal.Unknown0x1E);
}
Internal.Unknown0x1F = context.Reader.ReadByte();
if (Internal.Unknown0x1F != 1 && Internal.Unknown0x1F != 4)
{
context.Warnings.Add("FmatMaterialStructure.Unknown0x1F has unexpected value of "
+ Internal.Unknown0x1F);
}
// 16 empty bytes
if (!Array.TrueForAll(context.Reader.ReadUInt32s(4), (i) => { return i == 0; }))
{
context.Warnings.Add("FmatMaterialStructure padding not empty");
}
}
public override void Start()
{
Internals cC = baseObject.RequireComponent <Internals>();
}
private SocketError FinishOperationAccept(Internals.SocketAddress remoteSocketAddress)
{
SocketError socketError;
IntPtr localAddr;
int localAddrLength;
IntPtr remoteAddr;
try
{
_currentSocket.GetAcceptExSockaddrs(
_ptrSingleBuffer != IntPtr.Zero ? _ptrSingleBuffer : _ptrAcceptBuffer,
_count != 0 ? _count - _acceptAddressBufferCount : 0,
_acceptAddressBufferCount / 2,
_acceptAddressBufferCount / 2,
out localAddr,
out localAddrLength,
out remoteAddr,
out remoteSocketAddress.InternalSize
);
Marshal.Copy(remoteAddr, remoteSocketAddress.Buffer, 0, remoteSocketAddress.Size);
// Set the socket context.
IntPtr handle = _currentSocket.SafeHandle.DangerousGetHandle();
socketError = Interop.Winsock.setsockopt(
_acceptSocket.SafeHandle,
SocketOptionLevel.Socket,
SocketOptionName.UpdateAcceptContext,
ref handle,
Marshal.SizeOf(handle));
if (socketError == SocketError.SocketError)
{
socketError = SocketPal.GetLastSocketError();
}
}
catch (ObjectDisposedException)
{
socketError = SocketError.OperationAborted;
}
return socketError;
}
public static SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int count, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
byte[] socketAddressBuffer = socketAddress.Buffer;
int socketAddressLen = socketAddress.Size;
bool isIPv4, isIPv6;
Socket.GetIPProtocolInformation(socket.AddressFamily, socketAddress, out isIPv4, out isIPv6);
SocketError errorCode;
if (!handle.IsNonBlocking)
{
errorCode = handle.AsyncContext.ReceiveMessageFrom(buffer, offset, count, ref socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, handle.ReceiveTimeout, out ipPacketInformation, out bytesTransferred);
}
else
{
if (!TryCompleteReceiveMessageFrom(handle.FileDescriptor, buffer, offset, count, socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, out bytesTransferred, out socketFlags, out ipPacketInformation, out errorCode))
{
errorCode = SocketError.WouldBlock;
}
}
socketAddress.InternalSize = socketAddressLen;
receiveAddress = socketAddress;
return errorCode;
}
public static SocketError ReceiveMessageFromAsync(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, Internals.SocketAddress socketAddress, ReceiveMessageOverlappedAsyncResult asyncResult)
{
asyncResult.SocketAddress = socketAddress;
bool isIPv4, isIPv6;
Socket.GetIPProtocolInformation(((Socket)asyncResult.AsyncObject).AddressFamily, socketAddress, out isIPv4, out isIPv6);
return handle.AsyncContext.ReceiveMessageFromAsync(buffer, offset, count, socketFlags, socketAddress.Buffer, socketAddress.InternalSize, isIPv4, isIPv6, asyncResult.CompletionCallback);
}
public static SocketError ReceiveFromAsync(SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, Internals.SocketAddress socketAddress, OverlappedAsyncResult asyncResult)
{
asyncResult.SocketAddress = socketAddress;
return handle.AsyncContext.ReceiveFromAsync(buffer, offset, count, socketFlags, socketAddress.Buffer, socketAddress.InternalSize, asyncResult.CompletionCallback);
}
public static void PrintVersion()
{
System.Console.WriteLine($"{Version.Name} {Version.Text}");
System.Console.WriteLine($"Build Date: " + Internals.GetBuildDate().ToLongDateString());
}
public static void Collect(object obj, NameValueCollection collection)
{
Internals.ParsePath(collection, null, obj);
}
private void DoConnect(EndPoint endPointSnapshot, Internals.SocketAddress socketAddress)
{
if (s_loggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "Connect", endPointSnapshot);
}
// This can throw ObjectDisposedException.
SocketError errorCode = SocketPal.Connect(_handle, socketAddress.Buffer, socketAddress.Size);
#if TRACE_VERBOSE
try
{
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::InternalConnect() SRC:" + Logging.ObjectToString(LocalEndPoint) + " DST:" + Logging.ObjectToString(RemoteEndPoint) + " Interop.Winsock.WSAConnect returns errorCode:" + errorCode);
}
catch (ObjectDisposedException) { }
#endif
// Throw an appropriate SocketException if the native call fails.
if (errorCode != SocketError.Success)
{
// Update the internal state of this socket according to the error before throwing.
SocketException socketException = SocketExceptionFactory.CreateSocketException((int)errorCode, endPointSnapshot);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "Connect", socketException);
}
throw socketException;
}
if (_rightEndPoint == null)
{
// Save a copy of the EndPoint so we can use it for Create().
_rightEndPoint = endPointSnapshot;
}
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::DoConnect() connection to:" + endPointSnapshot.ToString());
// Update state and performance counters.
SetToConnected();
if (s_loggingEnabled)
{
Logging.PrintInfo(Logging.Sockets, this, SR.Format(SR.net_log_socket_connected, LocalEndPoint, RemoteEndPoint));
Logging.Exit(Logging.Sockets, this, "Connect", "");
}
}
/// <param name="input">Javascript value</param>
/// <param name="output">Will have the primitive type of the input when the function returns</param>
/// <param name="stringHint">Specifies whether the hint is string or number. Default is number.</param>
//public static void Run(ref mdr.DValue input, out mdr.DValue output, bool stringHint = false)
//{
// mdr.ValueTypes inputType = input.ValueType;
// if (mdr.ValueTypesHelper.IsObject(inputType))
// Internals.DefaultValue(ref input, out output, stringHint);
// else // type is a primitive type
// output = input;
//}
public static void Run(mdr.DObject input, ref mdr.DValue output, bool stringHint = false)
{
Internals.DefaultValue(input, out output, stringHint);
}
public void SomeBasicClass()
{
internals = new Internals(true);
}
public static Task ProcessMessage <T>(T bot, BotUserIdentifier user, string msg) where T : BotModel
{
return(Task.Run(async() =>
{
try
{
BotManager.Instance.Messages.Add(new ChatMessage {
ChatBotName = typeof(T).Name, Identification = user.ToString(), RawMessage = msg
});
var command = msg.Split(' ')[0];
var filter = new HashSet <string>();
// IsSenario = 0/1
// Senario = <string>
var option = new Dictionary <string, string>();
Log.Logs.Instance.Push("[Bot] Received Message - " + msg + "\r\n" + Log.Logs.SerializeObject(user));
UserDBModel userdb = null;
var query_user = BotManager.Instance.Users.Where(x => x.ChatBotId == user.ToString()).ToList();
if (query_user != null && query_user.Count > 0)
{
userdb = query_user[0];
if (userdb.Filtering != null)
{
userdb.Filtering.Split(",").ToList().ForEach(x => filter.Add(x));
}
if (userdb.Option != null)
{
option = JsonConvert.DeserializeObject <Dictionary <string, string> >(userdb.Option);
}
}
if (option.ContainsKey("IsSenario") && option["IsSenario"] == "1")
{
await Senario(bot, user, msg, userdb, option, filter);
return;
}
switch (command.ToLower())
{
case "/start":
{
if (userdb == null)
{
userdb = new UserDBModel {
ChatBotId = user.ToString(), ChatBotName = typeof(T).Name, Filtering = ""
};
BotManager.Instance.UserDB.Add(userdb);
BotManager.Instance.Users.Add(userdb);
}
}
{
var builder = new StringBuilder();
builder.Append("인하대 알림봇\r\n");
builder.Append("\r\n");
builder.Append("인하대 알림봇을 구독해주셔서 감사합니다!\r\n");
builder.Append("기본적인 설정을 위해 다음 옵션 중 하나를 선택해주세요!\r\n");
builder.Append("\r\n");
builder.Append("1. 인하대 공식 공지사항만 받겠습니다.\r\n");
builder.Append("2. 학과 공지사항도 같이 받겠습니다.\r\n");
builder.Append("\r\n");
builder.Append("'1' 또는 '2' 숫자만 입력해주세요.\r\n");
option = new Dictionary <string, string>();
option.Add("IsSenario", "1");
option.Add("Senario", "start01");
userdb.Option = JsonConvert.SerializeObject(option);
BotManager.Instance.UserDB.Update(userdb);
await bot.SendMessage(user, builder.ToString());
}
break;
case "/recent":
await bot.SendMessage(user, ExtractManager.InhaUnivArticles.Last().ToString());
break;
case "/filterlist":
{
var builder = new StringBuilder();
builder.Append($"[인하대 공식 홈페이지 필터링]\r\n");
ExtractManager.InhaUnivFilters.ToList().ForEach(x => builder.Append($"{x}\r\n"));
builder.Append($"\r\n");
builder.Append($"[학과 홈페이지 필터링]\r\n");
builder.Append($"추가 예정입니다!\r\n");
await bot.SendMessage(user, builder.ToString());
}
break;
case "/myfilter":
if (userdb.Filtering != null)
{
await bot.SendMessage(user, userdb.Filtering);
}
break;
case "/help":
{
var builder = new StringBuilder();
builder.Append($"인하대 알림봇 - {Version.Text}\r\n");
builder.Append("\r\n");
builder.Append("/start => 알림봇을 다시 설정합니다.\r\n");
builder.Append("/recent => 가장 최근의 알림을 가져옵니다.\r\n");
builder.Append("/filterlist => 필터링 가능한 모든 목록을 가져옵니다.\r\n");
builder.Append("/myfilter => 내 필터링 정보를 가져옵니다.\r\n");
builder.Append("/rap => 관리자 권한을 요청합니다.\r\n");
builder.Append("/gg <메시지> => 채널 관리자에게 메시지를 남깁니다.(고장 문의 등)\r\n");
if (filter.Contains("ADMIN"))
{
builder.Append("/msg <Type> <Id> <메시지> => 특정 사용자에게 메시지를 보냅니다.\r\n");
builder.Append("/notice <메시지> => 모든 사용자에게 메시지를 보냅니다.\r\n");
}
builder.Append("/info => 봇 정보를 가져옵니다.\r\n");
await bot.SendMessage(user, builder.ToString());
}
break;
case "/rap":
{
var cc = msg.Trim().Split(' ');
if (cc.Length == 1)
{
await bot.SendMessage(user, "적절한 요청이 아닙니다!");
return;
}
var aim = msg.Replace(cc[0], "").Trim();
if (!string.IsNullOrEmpty(Settings.Instance.Model.BotSettings.AccessIdentifierMessage) &&
aim == Settings.Instance.Model.BotSettings.AccessIdentifierMessage)
{
userdb.Filtering += ",ADMIN";
BotManager.Instance.UserDB.Update(userdb);
await bot.SendMessage(user, $"새로운 신원 '{user.ToString()}'에 관리자 권한을 추가했습니다.");
}
else
{
await bot.SendMessage(user, "액세스 식별자가 비어있거나 입력값과 다릅니다.");
}
}
break;
case "/gg":
{
var builder = new StringBuilder();
builder.Append($"사용자 메시지\r\n");
builder.Append($"식별자: {userdb.ChatBotName} - {userdb.ChatBotId}\r\n");
builder.Append($"메시지: {msg.Replace(msg.Trim().Split(' ')[0], "").Trim()}");
await BotManager.Instance.Notice(builder.ToString(), "ADMIN-GG");
}
break;
case "/msg":
{
if (!filter.Contains("ADMIN"))
{
await bot.SendMessage(user, "이 명령을 이용할 권한이 없습니다.");
return;
}
var cc = msg.Trim().Split(' ');
var builder = new StringBuilder();
builder.Append($"[알림봇 관리자 메시지]\r\n");
builder.Append(string.Join(' ', cc.Skip(3)));
if (await BotManager.Instance.Send(builder.ToString(), cc[1], cc[2]))
{
await bot.SendMessage(user, "성공");
}
else
{
await bot.SendMessage(user, "실패");
}
}
break;
case "/notice":
{
if (!filter.Contains("ADMIN"))
{
await bot.SendMessage(user, "이 명령을 이용할 권한이 없습니다.");
return;
}
var cc = msg.Trim().Split(' ');
var builder = new StringBuilder();
builder.Append($"[알림봇 공지사항]\r\n");
builder.Append(string.Join(' ', cc.Skip(1)));
await BotManager.Instance.Notice(builder.ToString(), "MSG-NOTICE");
}
break;
case "/info":
{
var builder = new StringBuilder();
builder.Append($"인하대 알림봇 - {Version.Text}\r\n");
builder.Append("\r\n");
builder.Append($"바이너리: {Version.Name} {Version.Text}\r\n");
builder.Append($"빌드시간: {Internals.GetBuildDate().ToLongDateString()}\r\n");
builder.Append($"실행시간: {Program.StartTime.ToLongTimeString()}\r\n");
builder.Append($"루프횟수: {Loop.Count}회 (10분마다 업데이트됨)\r\n");
//builder.Append($"채널관리자: [email protected]\r\n");
//builder.Append($"소드코드: https://github.com/rollrat/inha-alarmbot\r\n");
builder.Append("\r\n");
builder.Append("디스코드 알림봇: http://inhaalarmbot.kro.kr\r\n");
builder.Append("텔레그램 알림봇: https://t.me/inhanoticebot\r\n");
await bot.SendMessage(user, builder.ToString());
}
break;
default:
await bot.SendMessage(user, $"'{command}'은/는 적절한 명령어가 아닙니다!\r\n자세한 정보는 '/help' 명령어를 통해 확인해주세요!");
break;
}
}
catch (Exception e)
{
try
{
Log.Logs.Instance.PushError("[Bot Error] " + e.Message + "\r\n" + e.StackTrace);
await bot.SendMessage(user, "서버오류가 발생했습니다! 관리자에게 문의해주세요!");
}
catch (Exception e2)
{
Log.Logs.Instance.PushError("[Bot IError] " + e2.Message + "\r\n" + e2.StackTrace);
}
}
}));
}
private void DoBind(EndPoint endPointSnapshot, Internals.SocketAddress socketAddress)
{
// Mitigation for Blue Screen of Death (Win7, maybe others).
IPEndPoint ipEndPoint = endPointSnapshot as IPEndPoint;
if (!OSSupportsIPv4 && ipEndPoint != null && ipEndPoint.Address.IsIPv4MappedToIPv6)
{
SocketException socketException = new SocketException((int)SocketError.InvalidArgument);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "DoBind", socketException);
}
throw socketException;
}
// This may throw ObjectDisposedException.
SocketError errorCode = SocketPal.Bind(
_handle,
socketAddress.Buffer,
socketAddress.Size);
#if TRACE_VERBOSE
try
{
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::Bind() SRC:" + Logging.ObjectToString(LocalEndPoint) + " Interop.Winsock.bind returns errorCode:" + errorCode);
}
catch (ObjectDisposedException) { }
#endif
// Throw an appropriate SocketException if the native call fails.
if (errorCode != SocketError.Success)
{
// Update the internal state of this socket according to the error before throwing.
SocketException socketException = new SocketException((int)errorCode);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "DoBind", socketException);
}
throw socketException;
}
if (_rightEndPoint == null)
{
// Save a copy of the EndPoint so we can use it for Create().
_rightEndPoint = endPointSnapshot;
}
}
public static SocketError SendToAsync(SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, Internals.SocketAddress socketAddress, OverlappedAsyncResult asyncResult)
{
asyncResult.SocketAddress = socketAddress;
return handle.AsyncContext.SendToAsync(buffer, offset, count, GetPlatformSocketFlags(socketFlags), socketAddress.Buffer, socketAddress.Size, asyncResult.CompletionCallback);
}
