private static TResult Deserialize <TResult>(BytesSegment last)
{
var seqs = new System.Buffers.ReadOnlySequence <byte>(last.First, 0, last, last.Length);
var jr = new Utf8JsonReader(seqs);
return(JsonSerializer.Deserialize <TResult>(ref jr));
}
public override void Update(BytesSegment bs)
{
bs.CheckAsParameter();
var pos = bs.Offset;
var end = pos + bs.Len;
var keyStreamBuf = this.keyStreamBuf;
fixed(byte *bytes = bs.Bytes)
{
while (pos < end)
{
var remainningKeystream = KeystreamBufferSize - keystreamBufferPos;
if (remainningKeystream == 0)
{
keystreamBufferPos = 0;
remainningKeystream = KeystreamBufferSize;
var ksb = keyStreamBuf;
for (int i = 0; i < KsBlockCount; i++)
{
ksb[i] = counter;
if (++counter.v1 == 0)
{
++counter.v0;
}
Cipher.encrypt_64_128(keys, &ksb[i]);
}
}
var count = end - pos;
count = count < remainningKeystream ? count : remainningKeystream;
NaiveUtils.XorBytesUnsafe((byte *)keyStreamBuf + keystreamBufferPos, bytes + pos, (uint32)count);
pos += count;
keystreamBufferPos += count;
}
}
}
public override void Update(BytesSegment bs)
{
bs.CheckAsParameter();
var pos = bs.Offset;
var end = pos + bs.Len;
while (pos < end)
{
var remainningFeed = toBeFeedBack.Length - feedingPos;
if (remainningFeed == 0)
{
feedingPos = 0;
remainningFeed = toBeFeedBack.Length;
EcbTransform.TransformBlock(toBeFeedBack, 0, toBeFeedBack.Length, feedingBack, 0);
}
var feedEnd = pos + remainningFeed;
var thisBlockEnd = (feedEnd < end) ? feedEnd : end;
var count = thisBlockEnd - pos;
if (IsEncrypting)
{
NaiveUtils.XorBytes(feedingBack, feedingPos, bs.Bytes, pos, (uint)count);
NaiveUtils.CopyBytes(bs.Bytes, pos, toBeFeedBack, feedingPos, count);
}
else
{
NaiveUtils.CopyBytes(bs.Bytes, pos, toBeFeedBack, feedingPos, count);
NaiveUtils.XorBytes(feedingBack, feedingPos, bs.Bytes, pos, (uint)count);
}
pos += count;
feedingPos += count;
}
}
public override Task WriteAsyncImpl(BytesSegment bv)
{
var e = writeArgPool.GetValue();
e.SetBuffer(bv.Bytes, bv.Offset, bv.Len);
return(SendAsync(e));
}
protected override Task <int> ReadAsyncImpl(BytesSegment bs)
{
var e = readArgPool.GetValue();
var userToken = ((ReadUserToken)e.UserToken);
var tcs = _unusedReadTcs ?? new TaskCompletionSource <int>();
_unusedReadTcs = null;
userToken.tcs = tcs;
var sw = userToken.sw = this;
e.SetBuffer(bs.Bytes, bs.Offset, bs.Len);
try {
if (Socket.ReceiveAsync(e)) // if opearation not completed synchronously
{
return(tcs.Task);
}
} catch (Exception) {
recycleReadArgs(e, userToken);
throw;
}
var r = ReadCompleted(e, userToken, sw, out var ex);
if (r < 0)
{
throw ex;
}
_unusedReadTcs = tcs;
return(NaiveUtils.GetCachedTaskInt(r));
}
private /*async ValueTask*/ void OnReceiveMessage(BytesSegment frame, bool isEnd)
{
if (!isEnd)
{
if (pending != null)
{
pending.Append(frame);
}
pending = frame;
}
else
{
//检查有没有前面的消息帧
if (pending != null)
{
pending.Append(frame);
pending = null;
}
//开始读取消息标识并从挂起请求中查找
var msgId = ReadMsgIdFromResponse(frame.First);
if (waits.TryGetValue(msgId, out PooledTaskSource <object> tcs))
{
tcs.SetResult(frame); //注意为最后一包
}
else
{
BytesSegment.ReturnAll(frame.First);
}
}
}
public override void Update(BytesSegment bs)
{
bs.CheckAsParameter();
var pos = (uint)bs.Offset;
var end = pos + (uint)bs.Len;
fixed(Context *ctx = &this.ctx)
fixed(byte *bytes = bs.Bytes)
{
while (pos < end)
{
var remainningKeystream = KeystreamBufferSize - keystreamBufferPos;
if (remainningKeystream == 0)
{
keystreamBufferPos = 0;
remainningKeystream = KeystreamBufferSize;
NextKeystreamBuffer(ctx);
}
var count = end - pos;
count = count < remainningKeystream ? count : remainningKeystream;
NaiveUtils.XorBytesUnsafe(ctx->keyStreamBuffer + keystreamBufferPos, bytes + pos, count);
pos += count;
keystreamBufferPos += count;
}
}
}
public async Task <int> ReadAsync(BytesSegment bs)
{
lock (_syncRoot) {
if (tcsNewBuffer?.IsCompleted == false)
{
throw new Exception("another recv task is running.");
}
if (buffer.Len == 0 & !recvEOF)
{
tcsNewBuffer.Reset();
}
}
if (tcsNewBuffer != null)
{
await tcsNewBuffer;
}
lock (_syncRoot) {
if (recvEOF && buffer.Len == 0)
{
return(0);
}
int read = Math.Min(bs.Len, buffer.Len);
buffer.CopyTo(bs, 0, read);
buffer.SubSelf(read);
if (buffer.Len == 0)
{
buffer = new BytesSegment();
tcsBufferEmptied.SetResult(0);
}
return(read);
}
}
public async Task <int> ReadAsync(BytesSegment bs)
{
var pos = 0;
var curnode = latestMsg;
if (curnode == null || curnode.tlen == 0)
{
curnode = (await MsgStream.RecvMsgR(null)).Data;
if (curnode == null)
{
return(0);
}
}
do
{
if (curnode.len > 0)
{
var size = Math.Min(bs.Len, curnode.len);
Buffer.BlockCopy(curnode.bytes, curnode.offset, bs.Bytes, bs.Offset + pos, size);
curnode.SubSelf(size);
pos += size;
}
} while (pos < bs.Len && (curnode = curnode.nextNode) != null);
if (curnode == null || curnode.tlen == 0)
{
latestMsg = null;
}
else
{
latestMsg = curnode;
}
return(pos);
}
public static async Task ReadFullImpl(IMyStream myStream, BytesSegment bs)
{
int pos = 0;
if (myStream is IMyStreamReadR r)
{
while (pos < bs.Len)
{
var read = await r.ReadAsyncR(bs.Sub(pos));
if (read == 0)
{
throw new DisconnectedException($"unexpected EOF while ReadFull() (count={bs.Len}, pos={pos})");
}
pos += read;
}
return;
}
while (pos < bs.Len)
{
var read = await myStream.ReadAsync(bs.Sub(pos)).CAF();
if (read == 0)
{
throw new DisconnectedException($"unexpected EOF while ReadFull() (count={bs.Len}, pos={pos})");
}
pos += read;
}
}
public void OnReadFromDest(BytesSegment bs)
{
Request.EnsureSniffer();
Request.Sniffer.ServerData(Request, bs);
Request.BytesCountersRW.W.Add(bs.Len);
Result.Adapter.GetAdapter().BytesCountersRW.R.Add(bs.Len);
}
public void OnWriteToDest(BytesSegment bs)
{
Request.EnsureSniffer();
Request.Sniffer.ClientData(Request, bs);
Request.BytesCountersRW.R.Add(bs.Len);
Result.Adapter.GetAdapter().BytesCountersRW.W.Add(bs.Len);
}
private void StartReceiveAsync()
{
Task.Run(async() =>
{
ValueWebSocketReceiveResult result;
BytesSegment frame;
do
{
frame = BytesSegment.Rent();
try
{
result = await socket.ReceiveAsync(frame.Buffer.AsMemory(), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
BytesSegment.ReturnOne(frame);
break;
}
}
catch (Exception ex)
{
BytesSegment.ReturnOne(frame);
Console.WriteLine($"WebSocket receive error: {ex.Message}");
//TODO:考虑开始重新连接
break;
}
frame.Length = result.Count;
OnReceiveMessage(frame, result.EndOfMessage); //不需要捕获异常
} while (true);
});
}
/// <summary>
/// 归还缓存块
/// </summary>
/// <remarks>
/// 1.客户端调用系统服务后;
/// 2.客户端转发调用至子进程后;
/// 3.子进程调用转发的请求后.
/// </remarks>
internal void ReturnBuffer()
{
if (Count == FromWebSocket)
{
Debug.Assert(Arg1.ObjectValue != null);
BytesSegment.ReturnAll((BytesSegment)Arg1.ObjectValue);
}
}
public static AwaitableWrapper WriteAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamWriteR myStreamReuse)
{
return(myStreamReuse.WriteAsyncR(bs));
}
return(new AwaitableWrapper(myStream.WriteAsync(bs)));
}
public static AwaitableWrapper <int> ReadAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamReadR myStreamReuse)
{
return(myStreamReuse.ReadAsyncR(bs));
}
return(new AwaitableWrapper <int>(myStream.ReadAsync(bs)));
}
protected virtual int TryWriteNonblocking(BytesSegment bs)
{
if (Socket.Poll(0, SelectMode.SelectWrite))
{
return(Socket.Send(bs.Bytes, bs.Offset, bs.Len, SocketFlags.None));
}
return(0);
}
protected virtual AwaitableWrapper ReadFullAsyncRImpl(BytesSegment bs)
{
if (readStateMachine == null)
{
readStateMachine = new ReadFullRStateMachine();
}
return(new AwaitableWrapper(readStateMachine.Start(this, bs)));
}
protected int ReadSocketDirectSync(BytesSegment bs)
{
int r;
r = SocketReadImpl(bs);
removeAvailable(r);
return(r);
}
public AwaitableWrapper WriteAsyncR(BytesSegment bs)
{
if (!ivSent)
{
return(new AwaitableWrapper(WriteAsync(bs)));
}
sendEnc.Update(bs);
return(BaseStream.WriteAsyncR(bs));
}
private void Dequeue(BytesSegment bs, int len)
{
Queue.CopyTo(bs, len);
Queue.SubSelf(len);
if (Queue.Len == 0)
{
Queue.ResetSelf();
}
}
/// <summary>
/// 读取调用请求的消息头，不读取参数，仅用于WebSocket通道
/// </summary>
/// <returns>消息头至参数数组开始消耗的字节数，-1表示空参数列表</returns>
/// <remarks>目前实现只从第一包读取，即消息头长度不能超过一包的长度</remarks>
internal static int ReadRequireHead(BytesSegment first, ref int id, ref string service)
{
if (first.First != first)
{
throw new ArgumentException(nameof(first));
}
var jr = new Utf8JsonReader(first.Buffer.AsSpan());
if (!jr.Read() || jr.TokenType != JsonTokenType.StartObject)
{
throw RequireFormatException;
}
//I property
if (!jr.Read() || jr.TokenType != JsonTokenType.PropertyName ||
!jr.ValueSpan.SequenceEqual(RequireIdPropertyName.AsSpan()))
{
throw RequireFormatException;
}
if (!jr.Read())
{
throw RequireFormatException;
}
id = jr.GetInt32();
//S property
if (!jr.Read() || jr.TokenType != JsonTokenType.PropertyName ||
!jr.ValueSpan.SequenceEqual(RequireServicePropertyName.AsSpan()))
{
throw RequireFormatException;
}
if (!jr.Read())
{
throw RequireFormatException;
}
service = jr.GetString();
//A property
if (!jr.Read() || jr.TokenType != JsonTokenType.PropertyName ||
!jr.ValueSpan.SequenceEqual(RequireArgsPropertyName.AsSpan()))
{
throw RequireFormatException;
}
if (!jr.Read() || jr.TokenType != JsonTokenType.StartArray)
{
throw RequireFormatException;
}
//注意预先判断参数数组是否为空
int arrtyStartIndex = (int)jr.TokenStartIndex; //注意返回指向参数数组开始,非jr.BytesConsumed
if (first.Buffer[arrtyStartIndex + 1] == (byte)']')
{
return(-1);
}
//不要使用以下判断，可能分成多包造成读错误
//if (jr.Read() && jr.TokenType == JsonTokenType.EndArray)
// return -1;
return(arrtyStartIndex);
}
public override async void OnNewConnection(TcpClient client)
{
try {
using (client) {
var socket = client.Client;
var remoteEP = socket.RemoteEndPoint as IPEndPoint;
var dataStream = getEncryptionStream(GetMyStreamFromSocket(socket));
var buf = new BytesSegment(new byte[3]);
await dataStream.ReadFullAsyncR(buf).CAF(); // read ahead
var addrType = (Socks5Server.AddrType)buf[0];
string addrString = null;
switch (addrType)
{
case Socks5Server.AddrType.IPv4Address:
case Socks5Server.AddrType.IPv6Address:
var buf2 = new byte[addrType == Socks5Server.AddrType.IPv4Address ? 4 : 16];
buf2[0] = buf[1];
buf2[1] = buf[2];
await dataStream.ReadFullAsyncR(new BytesSegment(buf2, 2, buf2.Length - 2)).CAF();
var ip = new IPAddress(buf2);
addrString = ip.ToString();
break;
case Socks5Server.AddrType.DomainName:
var length = buf[1];
if (length == 0)
{
Logger.warning($"zero addr length ({remoteEP})");
await Task.Delay(10 * 1000).CAF();
return;
}
var dnBuf = new byte[length];
dnBuf[0] = buf[2];
await dataStream.ReadFullAsyncR(new BytesSegment(dnBuf, 1, length - 1)).CAF();
addrString = Encoding.ASCII.GetString(dnBuf, 0, length);
break;
default:
Logger.warning($"unknown addr type {addrType} ({remoteEP})");
await Task.Delay(10 * 1000 + NaiveUtils.Random.Next(20 * 1000)).CAF();
return;
}
await dataStream.ReadFullAsyncR(buf.Sub(0, 2)).CAF();
int port = buf[0] << 8 | buf[1];
var dest = new AddrPort(addrString, port);
await Controller.HandleInConnection(InConnectionTcp.Create(this, dest, dataStream, $"remote={remoteEP}")).CAF();
}
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, "handling connection");
}
}
public override AwaitableWrapper WriteAsyncRImpl(BytesSegment bs)
{
if (raW == null)
{
raW = new ReusableAwaiter <VoidType> .BeginEndStateMachine <SocketStream1>(this, WriteEndMethod);
}
raW.Reset();
WriteBeginMethod(this, bs, raW.ArgCallback, raW.ArgState);
return(new AwaitableWrapper(raW));
}
public int Read(BytesSegment bs)
{
var bufRead = TryReadInternalBuffer(bs);
if (bufRead > 0)
{
return(bufRead);
}
return(ReadSocketDirectSync(bs));
}
private async Task <int> ComplexRead(BytesSegment bs)
{
await WaitBeforeRead;
WaitBeforeRead = AwaitableWrapper.GetCompleted();
var r = await _ReadAsyncR(bs, true);
OnRead(bs.Sub(0, r));
return(r);
}
public static AwaitableWrapper ReadFullAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamReadFullR fullR)
{
return(fullR.ReadFullAsyncR(bs));
}
else
{
return(new AwaitableWrapper(new ReadFullRStateMachine().Start(myStream, bs)));
}
}
private int TryDequeue(BytesSegment bs)
{
if (Queue.Len == 0)
{
return(0);
}
var r = Math.Min(Queue.Len, bs.Len);
Dequeue(bs, r);
return(r);
}
private int ReadSync_SocketHaveAvailableData(BytesSegment bs)
{
Interlocked.Increment(ref ctr.Rsync);
var read = ReadSocketDirectSync(bs);
if (read <= 0)
{
throw new Exception($"{this} should not happen: Socket.Receive() returns {read} when Socket.Available > 0.");
}
return(read);
}
public override Task WriteAsyncImpl(BytesSegment bs)
{
Interlocked.Increment(ref ctr.Wasync);
lock (_write_lock) {
if (_write_last?.IsCompleted == false)
{
_write_last = WriteAsync_Wait(bs, _write_last);
}
_write_last = Task.Run(() => this.Socket.Send(bs.Bytes, bs.Offset, bs.Len, SocketFlags.None));
return(_write_last);
}
}
