public byte[] Encode(params dynamic[] values)
{
var stream = new MemoryStream();
if (values.Length == _definition.Inputs.Length)
{
try
{
var parameters = new AbiInputParameter[values.Length];
for (var index = 0; index < values.Length; index++)
{
parameters[index] = new AbiInputParameter(_definition.Inputs[index], values[index]);
}
stream.Append(_definition.Sha3Signature);
stream.Append(AbiParameterCoder.EncodeParameter(parameters));
}
catch
{
throw new ArgumentException("input values invalid");
}
}
else
{
throw new ArgumentException("values number not match");
}
return(stream.ToArray());
}
/// <summary>
/// Get parsed messages from FileZilla admin interface
/// </summary>
/// <returns></returns>
public FileZillaMessage[] ReceiveMessages()
{
var data = Receive();
var list = new List <FileZillaMessage>();
using (var memoryStream = new MemoryStream())
{
memoryStream.Append(data);
using (var reader = new BinaryReader(memoryStream))
{
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
var b = reader.ReadByte();
var count = reader.ReadInt32();
while ((reader.BaseStream.Length - reader.BaseStream.Position) < count)
{
var buffer = Receive();
memoryStream.Append(buffer);
}
byte[] payload = reader.ReadBytes(count);
var message = new FileZillaMessage((MessageOrigin)(b & 0x3), (MessageType)(b >> 2), payload, ProtocolVersion);
list.Add(message);
}
}
}
return(list.ToArray());
}
public Stream Transform(Stream strm, Core.DataStore.IDataStore dataStore, object param)
{
var resultStream = new MemoryStream();
resultStream.Append(strm);
resultStream.Append(dataStore.GetReadStream((string)param));
resultStream.Seek(0, SeekOrigin.Begin);
return(resultStream);
}
private static void EncodeList(MemoryStream buffer, List <object> input)
{
buffer.Append(ListStart);
foreach (var item in input)
{
EncodeNextObject(buffer, item);
}
buffer.Append(ListEnd);
}
public string CalculateIDWithUnsigned(string origin)
{
if (!SimpleWallet.IsValidAddress(origin))
{
throw new ArgumentException("origin expected address");
}
byte[] signingHash = this.SigningHash();
MemoryStream stream = new MemoryStream();
stream.Append(signingHash);
stream.Append(origin.ToBytes());
return(Blake2b.CalculateHash(stream.ToArray()).ToHexString());
}
private static void EncodeDictionary(MemoryStream buffer, Dictionary <string, object> input)
{
buffer.Append(DictionaryStart);
// we need to sort the keys by their raw bytes, not the string
var sortedKeys = input.Keys.ToList().OrderBy(x => BitConverter.ToString(Encoding.UTF8.GetBytes(x)));
foreach (var key in sortedKeys)
{
EncodeString(buffer, key);
EncodeNextObject(buffer, input[key]);
}
buffer.Append(DictionaryEnd);
}
public void WithValidIEnumerableArray_AppendBytes()
{
using (var stream = new MemoryStream(10))
{
Assert.Throws <ArgumentNullException>(() => stream.Append(NullByteArray));
}
}
public void WithNullBuffer_ThrowsArgumentNullException()
{
using (var stream = new MemoryStream(10))
{
Assert.Throws <ArgumentNullException>(() => stream.Append(NullByteArray));
}
}
/// <summary>
/// Creates a test stream with a single way.
/// </summary>
/// <returns></returns>
public static Stream GetWayTestStream()
{
var stream = new MemoryStream();
var way1 = new Way()
{
Id = 1,
ChangeSetId = 1,
TimeStamp = DateTime.Now,
Tags = new TagsCollection(new Tag("name", "hu?")),
Nodes = new long[]
{
1,
2,
3
},
UserId = 1,
UserName = "******",
Version = 1,
Visible = true
};
stream.Append(way1);
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
StringToBuf(string s, MemoryStream ms)
{
if (s == "")
{
return(LenSerial.Encode(0, ms));
}
if (s == null)
{
return(LenSerial.EncodeNull(ms));
}
byte[] b = Encoding.UTF8.GetBytes(s);
if (b.LongLength > Int32.MaxValue)
{
throw new BufSeriaLenException("String to be encoded is too long.");
}
int lenBytes = LenSerial.Encode(b.Length, ms);
ms.Append(b);
return(lenBytes + b.Length);
}
public void WithValidBytes_AppendBytes()
{
using (var stream = new MemoryStream(10))
{
stream.Append(Bytes);
Assert.AreEqual(Bytes.Length, stream.Length, "Get Append value");
}
}
/// <summary>
/// Adds a byte to the stream.
/// </summary>
///
/// <param name="stream"> MemoryStream where the byte is added. </param>
/// <param name="b"> Byte to be added. </param>
///
public static void Append(this MemoryStream stream, byte b)
{
Span <byte> span = stackalloc byte[1];
span[0] = b;
stream.Append(span);
}
public void AppendTest()
{
using (var stream = new MemoryStream(10))
{
stream.Append(_bytes);
Assert.AreEqual(_bytes.Length, stream.Length, "Get Append value");
}
}
/// <summary>
/// TP_Link TCP commands are pseudo-encrypted (obfuscated)
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
static byte[] Encrypt(byte[] s)
{
MemoryStream stream = new MemoryStream();
stream.Append(0);
stream.Append(0);
stream.Append(0);
stream.Append((byte)s.Length);
var key = 171;
foreach (var c1 in s)
{
var c2 = c1 ^ key;
key = c2;
stream.Append((byte)c2);
}
return(stream.ToArray());
}
public void AddVIP191Signature(byte[] senderSignature, byte[] gasPayerSignature)
{
if (senderSignature == null || senderSignature.Length != 65)
{
throw new ArgumentException("SenderSignature invalid");
}
if (gasPayerSignature == null || gasPayerSignature.Length != 65)
{
throw new ArgumentException("GasPayerSignature invalid");
}
MemoryStream stream = new MemoryStream();
stream.Append(senderSignature);
stream.Append(gasPayerSignature);
this.Signature = stream.ToArray();
}
UInt16ToBuf(ushort u, MemoryStream ms)
{
Span <byte> b = stackalloc byte[2];
b[0] = (byte)(u >> 0);
b[1] = (byte)(u >> 8);
ms.Append(b);
return(b.Length);
}
BytesToBuf(byte[] buf, MemoryStream ms)
{
if (buf == null)
{
LenSerial.EncodeNull(ms);
return;
}
LenSerial.Encode(buf.Length, ms);
ms.Append(buf);
}
public void WithValidIEnumerable_AppendBytes()
{
IEnumerable <byte> enumerableByte = BitConverter.GetBytes(Value);
using (var stream = new MemoryStream(10))
{
stream.Append(enumerableByte);
Assert.AreEqual(4, stream.Length, "Get Append value");
}
}
public byte[] SigningHash(string delegateFor = "")
{
byte[] encode = RlpCode.Encode(Transaction.UnsignedRlpDefinition(), this.Body);
byte[] hash = Blake2b.CalculateHash(encode);
if (delegateFor.Length != 0)
{
if (SimpleWallet.IsValidAddress(delegateFor))
{
MemoryStream stream = new MemoryStream();
stream.Append(hash);
stream.Append(delegateFor.ToBytes());
return(Blake2b.CalculateHash(stream.ToArray()));
}
else
{
throw new ArgumentException("delegateFor expected address");
}
}
return(hash);
}
Int32ToBuf(int i, MemoryStream ms)
{
Span <byte> b = stackalloc byte[4];
b[0] = (byte)(i >> 0);
b[1] = (byte)(i >> 8);
b[2] = (byte)(i >> 16);
b[3] = (byte)(i >> 24);
ms.Append(b);
return(b.Length);
}
Encode(int len, MemoryStream ms)
{
if (len < (int)EncodedLen.L16)
{
ms.Append((byte)len);
return(1);
}
if (len <= ushort.MaxValue)
{
ms.Append((byte)EncodedLen.L16);
Serial.UInt16ToBuf((ushort)len, ms);
return(3);
}
ms.Append((byte)EncodedLen.L32);
Serial.Int32ToBuf(len, ms);
return(5);
}
/// <summary>
/// Message reader is almost equal as bytereader, but it does not return until a whole message is set
/// </summary>
/// <param name="packetReceived"></param>
protected void StartMessageReaderAsync(Action <byte[]> packetReceived)
{
int BufferSize = sizeof(int);
var commandBuilder = new MemoryStream();
var commandBuffer = new byte[BufferSize];
pipeStream.ReadAsync(
commandBuffer,
0,
commandBuffer.Length)
.ContinueWith(rt =>
{
if (rt.Result == 0)
{
Disconnect?.Invoke(this, EventArgs.Empty);
return;
}
commandBuilder.Append(commandBuffer);
while (!pipeStream.IsMessageComplete)
{
var length = pipeStream.Read(
commandBuffer,
0,
commandBuffer.Length);
if (rt.Result == 0)
{
Disconnect?.Invoke(this, EventArgs.Empty);
return;
}
commandBuilder.Append(commandBuffer, length);
}
//Return the message we received
packetReceived(commandBuilder.ToArray());
StartMessageReaderAsync(packetReceived);
});
}
/// <summary>
/// TP_Link TCP responses are pseudo-encrypted (obfuscated)
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
static byte[] Decrypt(byte[] s)
{
MemoryStream stream = new MemoryStream();
var key = 171;
foreach (var c1 in s.Skip(4))
{
var c2 = c1 ^ key;
key = c1;
stream.Append((byte)c2);
}
return(stream.ToArray());
}
private byte[] PrepareReaderSeRequest(byte[] package)
{
var requestStream = new MemoryStream();
requestStream.Append(_frameStart);
var command = Helpers.StringToByteArray(CommandCode.RfPackage);
requestStream.Append(command);
var sLength = BitConverter.GetBytes((short)package.Length); //SLEN - Length of package
requestStream.Append(sLength[1]);
requestStream.Append(sLength[0]);
var rLength = BitConverter.GetBytes((short)32); //RLEN - Estimated response length
requestStream.Append(rLength[1]);
requestStream.Append(rLength[0]);
requestStream.Append(new byte[] { 10 }); // Timeout
requestStream.Append(package);
requestStream.Append(_frameStop);
requestStream.Append(CalculateChecksum(requestStream.ToArray()));
return(requestStream.ToArray());
}
private byte[] PrepareRequest(string command, string param = null)
{
var requestStream = new MemoryStream();
requestStream.Append(_frameStart);
if (command != null)
{
var payload = Helpers.StringToByteArray(command);
requestStream.Append(payload);
}
if (param != null)
{
var payload = Helpers.StringToByteArray(param);
requestStream.Append(payload);
}
requestStream.Append(_frameStop);
requestStream.Append(CalculateChecksum(requestStream.ToArray()));
return(requestStream.ToArray());
}
Int64ToBuf(long l, MemoryStream ms)
{
Span <byte> b = stackalloc byte[8];
b[0] = (byte)(l >> 0);
b[1] = (byte)(l >> 8);
b[2] = (byte)(l >> 16);
b[3] = (byte)(l >> 24);
b[4] = (byte)(l >> 32);
b[5] = (byte)(l >> 40);
b[6] = (byte)(l >> 48);
b[7] = (byte)(l >> 56);
ms.Append(b);
return(b.Length);
}
CollectionToBuf <T>(ICollection <T> c, MemoryStream ms)
where T : IBufSeriable
{
if (c == null)
{
Serial.Int32ToBuf(-1, ms);
return;
}
int n = c.Count;
Serial.Int32ToBuf(n, ms);
foreach (var i in c)
{
ms.Append(i.Serialize());
}
}
private string ReadUniqueIdentify()
{
MemoryStream ByteBuilder = new MemoryStream();
byte[] content = new byte[UNIQUELENGTH];
using (FileStream fs = File.Open(UNIQUE_PATH, FileMode.Open)) {
int readed = 0;
while ((readed = fs.Read(content, 0, UNIQUELENGTH)) > 0)
{
ByteBuilder.Append(content, readed);
}
}
UTF8Encoding utf8 = new UTF8Encoding(true);
string Unique = utf8.GetString(ByteBuilder.ToArray());
//md5 hash
Unique = MessageDigest_Algorithm.getMd5Hash(Unique);
return(Unique);
}
/// <summary>
/// Creates a test stream with a single relation.
/// </summary>
/// <returns></returns>
public static Stream GetRelationTestStream()
{
var stream = new MemoryStream();
var relation1 = new Relation()
{
Id = 1,
ChangeSetId = 1,
TimeStamp = DateTime.Now,
Tags = new TagsCollection(new Tag("name", "hu?")),
Members = new RelationMember[]
{
new RelationMember()
{
Id = 1,
Role = "node",
Type = OsmGeoType.Node
},
new RelationMember()
{
Id = 2,
Role = "way",
Type = OsmGeoType.Way
},
new RelationMember()
{
Id = 3,
Role = "relation",
Type = OsmGeoType.Relation
}
},
UserId = 1,
UserName = "******",
Version = 1,
Visible = true
};
stream.Append(relation1);
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
private byte[] PrepareReaderRequest(string command, string param = null)
{
var requestStream = new MemoryStream();
requestStream.Append(_frameStart);
var payload = Helpers.StringToByteArray(command + param);
var sLength = BitConverter.GetBytes((short)payload.Length);
requestStream.Append(sLength[1]);
requestStream.Append(sLength[0]);
requestStream.Append(payload);
requestStream.Append(_frameStop);
requestStream.Append(CalculateChecksum(requestStream.ToArray()));
return(requestStream.ToArray());
}
private void HandleRecv(byte[] data)
{
switch (state)
{
case SocketState.HANDSHAKING:
// garbage collector will get rid of this, no need for Close()
MemoryStream request = new MemoryStream();
// check response
if (data[0] != GetVersion() && data[1] != 0)
{
// bad
Close();
}
request.Append(GetVersion());
// connect
request.Append(1);
// reserved
request.Append(0);
// dns or ipv4?
switch (Uri.CheckHostName(hs.host))
{
case UriHostNameType.Dns:
request.Append(3);
request.Append((byte)hs.host.Length);
break;
case UriHostNameType.IPv4:
request.Append(1);
break;
default:
// not supported
Console.WriteLine("Neither DNS nor IPv4");
return;
}
request.Append(Encoding.ASCII.GetBytes(hs.host));
byte[] bPort = BitConverter.GetBytes((UInt16)hs.port);
if (BitConverter.IsLittleEndian)
{
// network byte order is big endian
Array.Reverse(bPort);
}
request.Append(bPort);
byte[] buffer = request.ToArray();
state = SocketState.CONNECTING;
Send(buffer);
Receive();
break;
case SocketState.CONNECTING:
if (data[0] == 5 && data[1] == 0)
{
isConnected = true;
state = SocketState.CONNECTED;
// connect callback
if (onConnectCallback != null)
{
onConnectCallback(this);
}
}
else if(data[0] == 4 && data[1] == 0x5A)
{
isConnected = true;
state = SocketState.CONNECTED;
// connect callback
if (onConnectCallback != null)
{
onConnectCallback(this);
}
}
else
{
Close();
Console.WriteLine("Bad socks response while connecting");
}
break;
case SocketState.CONNECTED:
// packets are from proxied host
if (onReceiveCallback != null)
{
onReceiveCallback(this, data);
}
break;
}
}
