protected override void SendFragmentData()
{
if (sendTransporterTable == null)
{
return;
}
removeTransporterList.Clear();
foreach (var pair in sendTransporterTable)
{
var transporter = pair.Value;
int sendAmount = 0;
while (sendAmount < SendBytePerFrame)
{
FlagDef flag = FlagDef.None;
int dataSize = NetworkLinkerPool.MTU - HeaderSize - 7;
if (transporter.pos + dataSize > transporter.data.Length)
{
flag = FlagDef.Complete;
dataSize = transporter.data.Length - transporter.pos;
//Debug.Log ("Complete");
}
unsafe
{
fixed(byte *dataPtr = &transporter.data[transporter.pos])
{
using (var writer = new DataStreamWriter(dataSize + 7, Allocator.Temp)) {
writer.Write((byte)BuiltInPacket.Type.DataTransporter);
writer.Write((byte)TransporterType.LargeBytes);
writer.Write(transporter.hash);
writer.Write((byte)flag);
writer.WriteBytes(dataPtr, dataSize);
NetworkManager.Brodcast(writer, QosType.Reliable, true);
}
}
}
transporter.pos += dataSize;
sendAmount += dataSize;
if (flag == FlagDef.Complete)
{
removeTransporterList.Add(transporter.hash);
ExeceOnSendComplete(transporter, true);
break;
}
}
//Debug.Log ("SendFragmentData Hash=" + transporter.hash + ", Pos" + transporter.pos);
}
foreach (int hash in removeTransporterList)
{
sendTransporterTable.Remove(hash);
}
}
private void OnRecievePacketMethod(ushort senderPlayerId, byte type, DataStreamReader stream, DataStreamReader.Context ctx)
{
if (type == (byte)BuiltInPacket.Type.DataTransporter)
{
var transType = stream.ReadByte(ref ctx);
if (transType != Type)
{
return;
}
int hash = stream.ReadInt(ref ctx);
FlagDef flag = (FlagDef)stream.ReadByte(ref ctx);
bool isStart = (flag == FlagDef.Start);
bool isComplete = (flag == FlagDef.Complete);
Transporter transporter;
if (isStart)
{
transporter = RecieveStart(hash, stream, ref ctx);
transporter.hash = hash;
recieveTransporterTable[hash] = transporter;
OnRecieveStart?.Invoke(transporter);
}
else
{
transporter = recieveTransporterTable[hash];
RecieveFragmentData(hash, stream, ref ctx, transporter);
if (isComplete)
{
recieveTransporterTable.Remove(hash);
RecieveComplete(hash, transporter);
}
}
}
}
protected override async void SendFragmentData()
{
if (sendTransporterTable == null)
{
return;
}
if (!sendTransporterTable.Any(p => p.Value.isAwait))
{
foreach (int hash in removeTransporterList)
{
sendTransporterTable.Remove(hash);
}
removeTransporterList.Clear();
foreach (var pair in sendTransporterTable)
{
var transporter = pair.Value;
if (transporter.isAwait)
{
continue;
}
transporter.isAwait = true;
transporter.fileStream.Seek(transporter.pos, SeekOrigin.Begin);
int readSize = await transporter.fileStream.ReadAsync(transporter.buffer, 0, SendBytePerFrame);
int sendAmount = 0;
while (sendAmount < SendBytePerFrame)
{
//Debug.Log ("sendAmount=" + sendAmount + ", readSize" + readSize + ", pos" + transporter.pos);
FlagDef flag = FlagDef.None;
int dataSize = Mathf.Min(SendBytePerFrame - sendAmount, NetworkLinkerPool.MTU - HeaderSize - 7);
if (transporter.pos + dataSize > transporter.fileStream.Length)
{
flag = FlagDef.Complete;
dataSize = (int)transporter.fileStream.Length - transporter.pos;
}
unsafe
{
fixed(byte *dataPtr = &transporter.buffer[sendAmount])
{
using (var writer = new DataStreamWriter(dataSize + 7, Allocator.Temp)) {
writer.Write((byte)BuiltInPacket.Type.DataTransporter);
writer.Write((byte)TransporterType.File);
writer.Write(transporter.hash);
writer.Write((byte)flag);
//writer.Write ((ushort)dataSize);
writer.WriteBytes(dataPtr, dataSize);
NetworkManager.Brodcast(writer, QosType.Reliable, true);
}
}
}
transporter.pos += dataSize;
sendAmount += dataSize;
if (flag == FlagDef.Complete)
{
transporter.fileStream.Dispose();
removeTransporterList.Add(transporter.hash);
ExeceOnSendComplete(transporter, true);
break;
}
}
transporter.isAwait = false;
}
}
}
protected InjectedFeature(InjectableMethod method, Var output, IRng rng)
{
Method = method;
Output = output;
var maxFlags = 15;
bool overlaps;
do
{
var flag = method.Type.GetOrAddFlag(rng);
var(signed, bytes) = IntConstraints.GetProps(flag.Field.FieldType.ElementType);
var maxOverlaps = 10;
do
{
long? value;
IntConstraints constraints;
if (rng.NextBoolean())
{
value = null;
constraints = IntConstraints.Generate(rng, bytes, signed);
}
else
{
value = IntConstraints.NextInt(rng, bytes, signed);
constraints = null;
}
overlaps = false;
foreach (var feature in flag.Features)
{
if (feature.Value.HasValue)
{
if (value.HasValue && feature.Value.Value == value.Value)
{
overlaps = true;
}
else if (constraints != null && constraints.Contains(feature.Value.Value))
{
overlaps = true;
}
}
else
{
if (value.HasValue && feature.Constraints.Contains(value.Value))
{
overlaps = true;
}
else if (constraints != null && constraints.Overlaps(feature.Constraints))
{
overlaps = true;
}
}
if (overlaps)
{
break;
}
}
if (!overlaps)
{
Value = value;
Constraints = constraints;
flag.AddFeature(this);
Flag = flag;
break;
}
} while (maxOverlaps-- > 0);
} while (overlaps && maxFlags-- > 0);
if (overlaps)
{
throw new Exception("could not create flag for injected feature");
}
}
MethodDef CreateFlagCtor(FlagDef flag, Func <MethodSig, bool> validator)
{
MethodSig sig;
var cats = new List <Tuple <FieldDef, TypeSig> >();
var it = flag.Type;
var sm = it.TypeMapping.Source.Module;
do
{
var qarg = Rng.NextInt32(1, 5);
cats.Add(Tuple.Create(flag.Field, flag.Field.FieldType));
var fq = new Queue <FieldDef>(
it.TypeMapping.Source.Fields.Where(f => !f.IsStatic & !f.IsLiteral & !f.HasFieldRVA));
while (cats.Count < qarg)
{
if (fq.Count > 0)
{
var f = fq.Dequeue();
cats.Add(Tuple.Create(f, f.FieldType));
}
else
{
cats.Add(Tuple.Create <FieldDef, TypeSig>(null, sm.CorLibTypes.Int32));
}
}
cats.Shuffle(Rng);
var args = cats.Select(c => c.Item2).ToArray();
sig = MethodSig.CreateInstance(sm.CorLibTypes.Void, args);
} while (!validator(sig));
var ctor = new MethodDefUser(".ctor", sig, MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName |
MethodAttributes.Public)
{
Body = new CilBody {
MaxStack = 8
}
};
var i = 0;
foreach (var t in cats)
{
ctor.ParamDefs.Add(new ParamDefUser("a" + (i++), (ushort)i));
}
var sc = new SigComparer();
IMethod baseCtor;
var bc = it.Base?.Ctors.RandomElementOrDefault(Rng);
var emitter = DnextFactory.NewILEmitter(sm);
emitter.Emit(OpCodes.Ldarg_0);
if (bc != null)
{
foreach (var pd in bc.Parameters)
{
if (pd.IsNormalMethodParameter)
{
var f = ctor.Parameters.FirstOrDefault(p =>
p.IsNormalMethodParameter && sc.Equals(p.Type, pd.Type));
if (f != null && Rng.NextBoolean())
{
emitter.Ldarg(f);
}
else
{
Utils.RandomConst(emitter, pd.Type, Rng);
}
}
}
baseCtor = bc;
}
else
{
baseCtor = new MemberRefUser(sm, ".ctor",
MethodSig.CreateInstance(sm.CorLibTypes.Void),
sm.CorLibTypes.Object.TypeRef);
}
emitter.Call(baseCtor);
Parameter flagpar = null;
foreach (var p in ctor.Parameters)
{
if (p.IsNormalMethodParameter)
{
var t = cats[p.Index - 1];
if (t.Item1 != null)
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Ldarg(p);
emitter.Emit(Instruction.Create(OpCodes.Stfld, t.Item1));
if (t.Item1 == flag.Field)
{
flagpar = p;
}
}
}
}
emitter.Emit(OpCodes.Ret);
emitter.Replace(ctor.Body);
flag.SetCtor(ctor, flagpar);
return(ctor);
}
