public void RunningThread()
{
while (Running)
{
IPEndPoint remoteIP = new IPEndPoint(IPEndPoint.Address, Port);
var data = UdpClient.Receive(ref remoteIP);
if (data.Length < 12)
{
continue;
}
MemoryStream ms = new MemoryStream(data);
CytarStreamReader cr = new CytarStreamReader(ms);
var ssid = cr.ReadUInt32();
// Handle session setup
if (ssid == 0)
{
ssid = cr.ReadUInt32();
// Reset a existed session
if (ssid != 0)
{
if (Sessions.ContainsKey(ssid))
{
if (Sessions[ssid].RemoteIPAdress == remoteIP.Address)
{
Sessions[ssid].OnReset(UdpClient, remoteIP);
}
}
}
// Start a new session
else
{
ssid = (uint)remoteIP.GetHashCode();
UDPSession session = new UDPSession(remoteIP, UdpClient, QosType, ssid);
Sessions[ssid] = session;
session.StartInternal();
Task.Run(() =>
{
OnSessionSetupCallback?.Invoke(session);
});
continue;
}
}
if (!Sessions[ssid].RemoteIPAdress.Equals(remoteIP.Address))
{
continue;
}
if (Sessions[ssid].RemotePort != remoteIP.Port)
{
Sessions[ssid].OnReset(UdpClient, remoteIP);
}
Sessions[ssid].OnDataReceived(cr.ReadBytes(data.Length - 4));
}
foreach (var session in Sessions.Values)
{
session.CloseAndWait();
}
Sessions = null;
UdpClient.Dispose();
}
protected virtual void HandlePackage(byte[] buffer)
{
MemoryStream ms = new MemoryStream(buffer);
CytarStreamReader cr = new CytarStreamReader(ms);
var cid = cr.ReadInt32();
string apiName = cr.ReadString();
if (apiName == APIReturnHandlerAPI)
{
var returnID = cr.ReadInt32();
OnAPIReturn(returnID, ms);
return;
}
else if (apiName == ErrorHandlerAPI)
{
OnErrorCallback(cid, cr.ReadObject <RemoteException>());
return;
}
try
{
var(result, isVoid) = CallAPI(apiName, ms);
CallRemoteAPI(APIReturnHandlerAPI, cid, result);
}
catch (Exception ex)
{
CallRemoteAPI(ErrorHandlerAPI, new RemoteException(ex.Message));
}
}
public static object Deserialize(Type type, byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
using (CytarStreamReader cr = new CytarStreamReader(ms))
{
return(cr.ReadObject(type));
}
}
internal virtual void SendPackage(MemoryStream sourceStream)
{
lock (NetworkSession.OutputStream)
{
CytarStreamReader cr = new CytarStreamReader(sourceStream);
CytarStreamWriter cw = new CytarStreamWriter(NetworkSession.OutputStream);
cw.Write((int)sourceStream.Length);
cw.Write(cr.ReadBytes((int)sourceStream.Length));
//sourceStream.CopyTo(NetworkSession.OutputStream);
}
}
internal virtual byte[] ReadPackage(int sizeLimit = int.MaxValue)
{
lock (NetworkSession.InputStream)
{
CytarStreamReader cr = new CytarStreamReader(NetworkSession.InputStream);
var size = cr.ReadInt32();
if (size > sizeLimit)
{
throw new DataSizeException(sizeLimit, size);
}
return(cr.ReadBytes(size));
}
}
public virtual void OnAPIReturn(int cid, Stream returnStream)
{
if (!RemoteCallingRecode.ContainsKey(cid))
{
return;
}
CytarStreamReader cr = new CytarStreamReader(returnStream);
if (RemoteCallingRecode[cid].ReturnType == typeof(void))
{
RemoteCallingRecode[cid].Return(null);
}
else
{
RemoteCallingRecode[cid].Return(cr.ReadObject(RemoteCallingRecode[cid].ReturnType));
}
RemoteCallingRecode.Remove(cid);
}
public virtual (object, bool) CallAPI(string apiName, Stream stream)
{
var api = GetAPI(apiName);
var paramsList = new List <object>();
CytarStreamReader cr = new CytarStreamReader(stream);
foreach (var paramType in api.Parameters)
{
if (paramType.IsSubclassOf(typeof(Session)))
{
paramsList.Add(this);
}
else
{
paramsList.Add(cr.ReadObject(paramType));
}
}
return(api.Method.Invoke(api.APIContext, paramsList.ToArray()), api.Method.ReturnType == typeof(void));
}
public static object Vector4Deserialize(Stream stream)
{
CytarStreamReader cr = new CytarStreamReader(stream);
return(new Vector4(cr.ReadSingle(), cr.ReadSingle(), cr.ReadSingle(), cr.ReadSingle()));
}
