public new async Task AppendAllLinesAsync(IEnumerable <string> lines, CancellationToken cancellationToken = default)
{
if (lines is null || !lines.Any())
{
return;
}
IoHelpers.EnsureContainingDirectoryExists(NewFilePath);
if (File.Exists(NewFilePath))
{
File.Delete(NewFilePath);
}
var byteArrayBuilder = new ByteArrayBuilder();
var linesArray = lines.ToArray();
var linesIndex = 0;
using (var sr = OpenText())
using (var fs = File.OpenWrite(NewFilePath))
using (var sw = new StreamWriter(fs, Encoding.ASCII, Constants.BigFileReadWriteBufferSize))
{
// 1. First copy.
if (!sr.EndOfStream)
{
var lineTask = sr.ReadLineAsync();
Task wTask = Task.CompletedTask;
string line = null;
while (lineTask is { })
public static byte[] BuildReadScreenResponse(ScreenContent ScreenContent)
{
var ra = new ByteArrayBuilder();
// data stream header.
{
var buf = DataStreamHeader.Build(50, TerminalOpcode.ReadScreen, 0, 0);
ra.Append(buf);
}
// screen regeneration buffer. each byte on the screen.
{
var buf = ScreenContent.GetRegenerationBuffer();
ra.Append(buf);
}
// update length of response data stream.
{
var wk = new ByteArrayBuilder();
wk.AppendBigEndianShort((short)ra.Length);
ra.CopyToBuffer(wk.ToByteArray(), 0);
}
// IAC EOR
{
ra.Append(EOR_Command.Build());
}
return(ra.ToByteArray());
}
/// <summary>
/// Process a CONNECT request
/// </summary>
protected void ProcessConnect()
{
// Reset request
_requestBuilder = new ByteArrayBuilder();
try
{
// got a connect
string response = _requestInfo.HttpVersion + " 200 Connection established\r\nContent-length: 0\r\nProxy-Agent: Traffic Viewer Proxy\r\n\r\n";
byte[] line = Constants.DefaultEncoding.GetBytes(response);
HttpServerConsole.Instance.WriteLine(LogMessageType.Information,
"Sending response: 200 Connection established for request: {0}", _requestInfo.RequestLine);
// Give the OK
if (!TryWriteToStream(line))
{
return;
}
if (!TrySecureStream())
{
return;
}
// Keep reading on this now encrypted stream
ClientStreamWrapper.BeginRead(Buffer, 0, Buffer.Length, new AsyncCallback(OnRead), ClientStreamWrapper);
}
catch (Exception ex)
{
HttpServerConsole.Instance.WriteLine(LogMessageType.Error,
"SSL Connect failed: {0}", ex.Message);
ClientStreamWrapper.Close();
}
}
public new async Task WriteAllLinesAsync(IEnumerable <string> lines, CancellationToken cancellationToken = default)
{
if (lines is null || !lines.Any())
{
return;
}
var byteArrayBuilder = new ByteArrayBuilder();
foreach (var line in lines)
{
ContinueBuildHash(byteArrayBuilder, line);
}
var res = await WorkWithHashAsync(byteArrayBuilder, cancellationToken).ConfigureAwait(false);
if (res.same)
{
return;
}
await base.WriteAllLinesAsync(lines, cancellationToken).ConfigureAwait(false);
await WriteOutHashAsync(res.hash).ConfigureAwait(false);
}
private void HanlderModbusBaseRead(MasterReadDataBase masterReadData)
{
byte _readOrderCmd = 0x00;
if (masterReadData is ReadCoilsData)
{
_readOrderCmd = (byte)ModbusBaseOrderCmd.ReadCoilStatus;
}
else if (masterReadData is ReadDiscreteInputData)
{
_readOrderCmd = (byte)ModbusBaseOrderCmd.ReadInputStatus;
}
else if (masterReadData is ReadHoldingRegistersData)
{
_readOrderCmd = (byte)ModbusBaseOrderCmd.ReadHoldingRegister;
}
else if (masterReadData is ReadInputRegisters)
{
_readOrderCmd = (byte)ModbusBaseOrderCmd.ReadInputRegister;
}
if (_readOrderCmd != 0x00)
{
using (ByteArrayBuilder builder = new ByteArrayBuilder())
{
builder.Append(masterReadData.SlaveID); //高位在前
builder.Append(_readOrderCmd); //功能码
builder.Append(ByteHelper.ToBytes(masterReadData.Address, true)); //高位在前
builder.Append(ByteHelper.ToBytes(masterReadData.Quantity, true)); //数量
CRCCaluData = builder.ToArray();
}
}
}
private async Task <(bool same, byte[] hash)> WorkWithHashAsync(ByteArrayBuilder byteArrayBuilder, CancellationToken cancellationToken)
{
byte[] hash = null;
try
{
var bytes = byteArrayBuilder.ToArray();
hash = HashHelpers.GenerateSha256Hash(bytes);
if (File.Exists(DigestFilePath))
{
var digest = await File.ReadAllBytesAsync(DigestFilePath, cancellationToken).ConfigureAwait(false);
if (ByteHelpers.CompareFastUnsafe(hash, digest))
{
if (File.Exists(NewFilePath))
{
File.Delete(NewFilePath);
}
return(true, hash);
}
}
}
catch (Exception ex)
{
Logger.LogWarning("Failed to read digest.");
Logger.LogInfo(ex);
}
return(false, hash);
}
private void ContinueBuildHash(ByteArrayBuilder byteArrayBuilder, string line)
{
if (string.IsNullOrWhiteSpace(line))
{
byteArrayBuilder.Append(0);
}
else
{
if (DigestRandomIndex.HasValue)
{
int index = DigestRandomIndex == -1 || DigestRandomIndex >= line.Length // Last char.
? line.Length - 1
: DigestRandomIndex.Value;
var c = line[index];
var b = (byte)c;
byteArrayBuilder.Append(b);
}
else
{
var b = Encoding.ASCII.GetBytes(line);
byteArrayBuilder.Append(b);
}
}
}
public void TestClearChunk()
{
ByteArrayBuilder builder = new ByteArrayBuilder();
string firstChunk = "123";
string secondChunk = "ab";
byte[] firstChunkBytes = GetBytesFromString(firstChunk);
byte[] secondChunkBytes = GetBytesFromString(secondChunk);
builder.AddChunkReference(firstChunkBytes, 3);
builder.AddChunkReference(secondChunkBytes, 2);
byte[] returnedBytes = builder.ToArray();
string returnedBytesString = Encoding.UTF8.GetString(returnedBytes);
Assert.AreEqual("123ab", returnedBytesString);
//now clear
builder.ClearChunks();
Assert.AreEqual("", Encoding.UTF8.GetString(builder.ToArray()));
//check that the index gets reset after clear
builder.AddChunkReference(firstChunkBytes, 3);
returnedBytes = builder.ReadChunk();
returnedBytesString = Encoding.UTF8.GetString(returnedBytes);
Assert.AreEqual(firstChunk, returnedBytesString);
}
private static async Task <string> ReadCRLFLineAsync(Stream stream, Encoding encoding, CancellationToken ctsToken = default)
{
var bab = new ByteArrayBuilder();
while (true)
{
int ch = await stream.ReadByteAsync(ctsToken);
if (ch == -1)
{
break;
}
if (ch == '\r')
{
var ch2 = await stream.ReadByteAsync(ctsToken);
if (ch2 == '\n')
{
return(bab.ToString(encoding));
}
bab.Append(new byte[] { (byte)ch, (byte)ch2 });
continue;
}
bab.Append((byte)ch);
}
if (bab.Length > 0)
{
return(bab.ToString(encoding));
}
return(null);
}
public override void Serialize(ByteArrayBuilder cmd)
{
base.Serialize(cmd);
cmd.Set(3); // ??
cmd.Set(4); // ??
}
public async Task WriteAllLinesAsync(IEnumerable <string> lines, CancellationToken cancellationToken = default, bool dismissNullOrEmptyContent = true)
{
if (dismissNullOrEmptyContent)
{
if (lines is null || !lines.Any())
{
return;
}
}
var byteArrayBuilder = new ByteArrayBuilder();
foreach (var line in lines)
{
ContinueBuildHash(byteArrayBuilder, line);
}
var res = await WorkWithHashAsync(byteArrayBuilder, cancellationToken);
if (res.same)
{
return;
}
IoHelpers.EnsureContainingDirectoryExists(NewFilePath);
await File.WriteAllLinesAsync(NewFilePath, lines, cancellationToken);
SafeMoveNewToOriginal();
await WriteOutHashAsync(res.hash);
}
public new async Task WriteAllLinesAsync(IEnumerable <string> lines, CancellationToken cancellationToken = default, bool dismissNullOrEmptyContent = true)
{
if (dismissNullOrEmptyContent)
{
if (lines is null || !lines.Any())
{
return;
}
}
var byteArrayBuilder = new ByteArrayBuilder();
foreach (var line in lines)
{
ContinueBuildHash(byteArrayBuilder, line);
}
var res = await WorkWithHashAsync(byteArrayBuilder, cancellationToken);
if (res.same)
{
return;
}
await base.WriteAllLinesAsync(lines, cancellationToken, dismissNullOrEmptyContent);
await WriteOutHashAsync(res.hash);
}
// TODO HasUnsupportedOps?
public override void Serialize(ByteArrayBuilder cmd)
{
base.Serialize(cmd);
cmd.SetString(8, Name);
cmd.SetString(8 + Name.Length, Description);
}
public static async Task <string> ReadStartLineAsync(Stream stream, CancellationToken ctsToken = default)
{
// https://tools.ietf.org/html/rfc7230#section-3
// A recipient MUST parse an HTTP message as a sequence of octets in an
// encoding that is a superset of US-ASCII[USASCII].
// Read until the first CRLF
// the CRLF is part of the startLine
// https://tools.ietf.org/html/rfc7230#section-3.5
// Although the line terminator for the start-line and header fields is
// the sequence CRLF, a recipient MAY recognize a single LF as a line
// terminator and ignore any preceding CR.
var bab = new ByteArrayBuilder();
int read = 0;
while (read >= 0)
{
read = await stream.ReadByteAsync(ctsToken).ConfigureAwait(false);
bab.Append((byte)read);
if (LF == (byte)read)
{
break;
}
}
var startLine = bab.ToString(Encoding.ASCII);
if (string.IsNullOrEmpty(startLine))
{
throw new FormatException($"{nameof(startLine)} cannot be null or empty.");
}
return(startLine);
}
public override void ToByteArray(ByteArrayBuilder byteArrayBuilder)
{
byteArrayBuilder
.AddByte(Length)
.AddByte(DeviceState)
.AddInt(Lost);
}
public byte[] RawBytesToSend()
{
return(Match(i =>
{
switch (i)
{
case RequestInterruption.Abort:
return new[] { Bytes.CAN };
default:
return Array.Empty <byte>();
}
}, data =>
{
var crc = Crc16.Compute(data.Concat(new[] { Bytes.ETB }));
var crcByte1 = (byte)(crc / 256);
var crcByte2 = (byte)(crc % 256);
var bytes = new ByteArrayBuilder()
.Add(Bytes.SYN)
.Add(data)
.Add(Bytes.ETB)
.Add(crcByte1, crcByte2);
return bytes.ToArray();
}));
}
public void Serialize(ByteArrayBuilder cmd)
{
cmd.AddUInt16((int)Id);
cmd.AddString(20, LongName);
cmd.AddString(4, ShortName);
cmd.AddByte(0x00); // Xa
cmd.Pad(); // ??
cmd.AddByte((byte)(IsExternal ? 0x00 : 0x01)); // Xb
if (ExternalPorts == null)
{
cmd.AddBoolArray(false); // Is an external type, so no port options
}
else
{
cmd.AddBoolArray(ExternalPorts.Contains(ExternalPortType.SDI),
ExternalPorts.Contains(ExternalPortType.HDMI),
ExternalPorts.Contains(ExternalPortType.Component),
ExternalPorts.Contains(ExternalPortType.Composite),
ExternalPorts.Contains(ExternalPortType.SVideo));
}
cmd.AddByte((byte)(IsExternal ? 0x00 : 0x01)); // Xd
cmd.AddUInt8((int)ExternalPortType); // Xe
cmd.AddUInt8((int)InternalPortType);
cmd.Pad(); //Xg ??
cmd.AddUInt8((uint)SourceAvailability); // Xh
cmd.AddUInt8((uint)MeAvailability); // Xi
}
private static async Task <string> ReadCRLFLineAsync(Stream stream, Encoding encoding, CancellationToken ctsToken = default)
{
var bab = new ByteArrayBuilder();
while (true)
{
int ch = await stream.ReadByteAsync(ctsToken).ConfigureAwait(false);
if (ch == -1)
{
break;
}
if (ch == '\r')
{
var ch2 = await stream.ReadByteAsync(ctsToken).ConfigureAwait(false);
if (ch2 == '\n')
{
return(bab.ToString(encoding));
}
bab.Append(new byte[] { (byte)ch, (byte)ch2 });
continue;
}
bab.Append((byte)ch);
}
return(bab.Length > 0
? bab.ToString(encoding)
: throw new FormatException("There's no CRLF."));
}
private void RunResponseBodyTest(string contentType, byte[] expectedBody, Encoding expectedEncoding)
{
ByteArrayBuilder builder = new ByteArrayBuilder();
byte[] responseHead = Constants.DefaultEncoding.GetBytes(String.Format("HTTP/1.1 200 OK\r\nContent-Type: {0}\r\nContent-Length: {1}\r\n\r\n", contentType, expectedBody.Length));
builder.AddChunkReference(responseHead, responseHead.Length);
builder.AddChunkReference(expectedBody, expectedBody.Length);
byte[] expectedResponseBytes = builder.ToArray();
HttpRequestInfo expectedRequest = new HttpRequestInfo("GET / HTTP/1.1\r\n\r\n");
HttpResponseInfo expectedResponse = new HttpResponseInfo(expectedResponseBytes);
HttpRequestInfo receivedReqInfo;
HttpResponseInfo receivedRespInfo;
SendTestRequestToMockProxy(expectedRequest, expectedResponse,
out receivedReqInfo,
out receivedRespInfo);
string receivedResponseBody = receivedRespInfo.ResponseBody.ToString(receivedRespInfo.Headers["Content-Type"]);
Assert.AreEqual(expectedEncoding.GetString(expectedBody), receivedResponseBody);
}
public void Test_HttpClient_ResponseBody_Binary()
{
ByteArrayBuilder builder = new ByteArrayBuilder();
byte[] responseHead = Encoding.UTF8.GetBytes("HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length:4\r\n\r\n");
builder.AddChunkReference(responseHead, responseHead.Length);
builder.AddChunkReference(new byte[4] {
0, 1, 0, 1
}, 4);
HttpRequestInfo reqInfo = new HttpRequestInfo("GET /binary HTTP/1.1");
HttpResponseInfo respInfo = new HttpResponseInfo(builder.ToArray());
HttpRequestInfo receivedReqInfo;
HttpResponseInfo receivedResponseInfo;
SendTestRequestToMockProxy(reqInfo, respInfo, out receivedReqInfo, out receivedResponseInfo);
byte[] respBody = receivedResponseInfo.ResponseBody.ToArray();
Assert.AreEqual(4, respBody.Length);
Assert.AreEqual(0, respBody[0]);
Assert.AreEqual(1, respBody[1]);
Assert.AreEqual(0, respBody[2]);
Assert.AreEqual(1, respBody[3]);
}
public void Serialize(ByteArrayBuilder cmd)
{
cmd.AddBoolArray(Unknown);
cmd.AddBoolArray(Unknown2);
cmd.AddByte(BytePattern.Take((int)Length));
cmd.PadToNearestMultipleOf4();
}
public virtual byte[] ToBytes( )
{
var ba = new ByteArrayBuilder();
ba.Append(0x04);
ba.Append((byte)this.CmdCode);
return(ba.ToByteArray());
}
public void Serialize(ByteArrayBuilder cmd)
{
cmd.AddString(32, Name);
// TODO figure out what this is. It might mean something, or nothing. By blanking out after the name seems to cause the client to lose input names on the buttons
cmd.AddByte(0x28, 0x36, 0x9B, 0x60, 0x4C, 0x08, 0x11, 0x60);
cmd.AddUInt8((uint)Model);
cmd.AddByte(0x3D, 0xA4, 0x60);
}
public override void Serialize(ByteArrayBuilder cmd)
{
base.Serialize(cmd);
// TODO - specify max lengths on these
cmd.SetString(8, Name);
cmd.SetString(8 + Name.Length, Description);
}
/// <summary>
/// Serialize to ByteArray.
/// </summary>
/// <param name="byteArrayBuilder">The byte array builder.</param>
public override void ToByteArray(ByteArrayBuilder byteArrayBuilder)
{
byteArrayBuilder
.AddByte(Length)
.AddByte(this.CommunicationChannel)
.AddByte(this.SequenceCounter)
.AddByte(0) // reserved
.Add(this.Cemi.ToByteArray());
}
public static Tuple <int, byte[], TelnetLogList> ProcessTelnetCommand(
TelnetCommand TelnetCmd, NegotiateSettings NegotiateSettings,
bool doLog = false)
{
TelnetLogList logList = null;
if (doLog == true)
{
logList = new TelnetLogList();
}
int cx = 0;
var writeStream = new ByteArrayBuilder();
// write to the run log.
if (logList != null)
{
logList.AddItem(Direction.Read, TelnetCmd.ToString());
}
if (TelnetCmd.CmdCode == Enums.CommandCode.DO)
{
var replyStmt = TelnetCmd.BuildReply(NegotiateSettings);
writeStream.Append(replyStmt.ToBytes());
}
else if (TelnetCmd is NewEnvironCommand)
{
var envStmt = TelnetCmd as NewEnvironCommand;
cx = ProcessNewEnvironStatement(envStmt, writeStream, NegotiateSettings);
}
else if (TelnetCmd is TerminalTypeCommand)
{
var ttStmt = TelnetCmd as TerminalTypeCommand;
cx = ProcessTerminalTypeStatement(ttStmt, writeStream, NegotiateSettings);
}
else if ((TelnetCmd is EndOfRecordStatement) || (TelnetCmd is TransmitBinaryCommand))
{
if (TelnetCmd.CmdCode == Enums.CommandCode.DO)
{
var replyStmt = TelnetCmd.BuildReply(NegotiateSettings);
writeStream.Append(replyStmt.ToBytes());
if ((replyStmt.CmdCode == Enums.CommandCode.DO) &&
(replyStmt.Subject.IsEqual(TelnetSubject.TRANSMIT_BINARY)))
{
}
}
else if (TelnetCmd.CmdCode == Enums.CommandCode.WILL)
{
var replyStmt = TelnetCmd.BuildDoReply();
writeStream.Append(replyStmt.ToBytes());
}
}
return(new Tuple <int, byte[], TelnetLogList>(cx, writeStream.ToByteArray(), logList));
}
public override void Serialize(ByteArrayBuilder cmd)
{
base.Serialize(cmd);
if (SourceType == MediaPlayerSource.Clip)
{
cmd.SetByte(2, new byte[] { 0x00, (byte)SourceIndex });
}
}
public override void Serialize(ByteArrayBuilder cmd)
{
if (RunningToKeyFrame != FlyKeyKeyFrameType.RunToInfinite)
{
RunningToInfinite = 0;
}
base.Serialize(cmd);
}
public override byte[] ToBytes()
{
var ba = new ByteArrayBuilder();
var buf = base.ToBytes();
ba.Append(buf);
ba.Append(this.RequestByte);
return(ba.ToByteArray());
}
public override byte[] ToBytes()
{
var ba = new ByteArrayBuilder();
var buf = base.ToBytes();
ba.Append(buf);
ba.Append(this.ControlChars);
return(ba.ToByteArray());
}
public override void BuildAsByteArray(ByteArrayBuilder builder)
{
base.BuildAsByteArray(builder);
builder.Add(IsGameStarted);
builder.Add(DeckSize);
builder.Add(PlayerIndex);
builder.Add(Reverse);
builder.Add(Top);
builder.Add(Winner);
builder.AddList(Players);
builder.AddList(PlayerHandSizes);
builder.Add(Cards);
}
public override void BuildAsByteArray(ByteArrayBuilder builder)
{
base.BuildAsByteArray(builder);
builder.Add(Message);
}
public override void BuildAsByteArray(ByteArrayBuilder builder)
{
base.BuildAsByteArray(builder);
builder.Add(CardIndex);
builder.Add(Card);
}
public abstract void BuildAsByteArray(ByteArrayBuilder builder);
public byte[] AsByteArray()
{
var b = new ByteArrayBuilder();
BuildAsByteArray(b);
return b.GetByteArray();
}
public override void BuildAsByteArray(ByteArrayBuilder builder)
{
builder.Add(Type);
}
public override void BuildAsByteArray(ByteArrayBuilder builder)
{
base.BuildAsByteArray(builder);
builder.Add(Username);
}
