public static Int128 Int128Mul(long lhs, long rhs)
{
bool flag = lhs < 0 != rhs < 0;
if (lhs < 0)
{
lhs = -lhs;
}
if (rhs < 0)
{
rhs = -rhs;
}
ulong num = (ulong)lhs >> 32;
ulong num2 = (ulong)(lhs & uint.MaxValue);
ulong num3 = (ulong)rhs >> 32;
ulong num4 = (ulong)(rhs & uint.MaxValue);
ulong num5 = num * num3;
ulong num6 = num2 * num4;
ulong num7 = num * num4 + num2 * num3;
long num8 = (long)(num5 + (num7 >> 32));
ulong num9 = (num7 << 32) + num6;
if (num9 < num6)
{
num8++;
}
Int128 @int = new Int128(num8, num9);
return((!flag) ? @int : (-@int));
}
private bool CheckNewNonceHash(Int256 newNonce, Int128 newNonceHash)
{
byte[] hash = ComputeSHA1(newNonce.ToBytes());
Int128 nonceHash = hash.ToInt128();
return(nonceHash == newNonceHash);
}
private void CheckNonce(Int128 expectedNonce, Int128 actualNonce)
{
if (actualNonce != expectedNonce)
{
throw new InvalidResponseException(string.Format("Expected nonce {0:X16} differs from the actual nonce {1:X16}.", expectedNonce, actualNonce));
}
}
/// <summary>
/// Gets a hash digest of the entropy which has been accumulated.
/// Note: if no entropy has accumulated, the result is deterministic.
/// </summary>
public byte[] GetDigest()
{
byte[] result = null;
// See above for hash algorithm mess.
#if (NETSTANDARD2_0 || NETSTANDARD1_3)
if (_IncHash != null)
{
result = _IncHash.GetHashAndReset();
}
#endif
#if (NETSTANDARD2_0 || NET452)
if (_HashAlg != null)
{
// As the final block needs some input, we use part of the total entropy counter.
_HashAlg.TransformFinalBlock(BitConverter.GetBytes(TotalEntropyBytes.Low), 0, 8);
result = _HashAlg.Hash;
}
#endif
if (result == null)
{
ThrowGetDigestResultIsNull();
}
if (result.Length != _HashLengthInBytes)
{
ThrowDigestLengthIsWrong(result);
}
EntropyBytesSinceLastDigest = Int128.Zero;
_CountOfBytesBySource.Clear();
return(result);
}
internal static Int128 ReverseEndianness(Int128 value)
{
return(new Int128(
ReverseEndianness(value.Lower),
ReverseEndianness(value.Upper)
));
}
/// <summary>
/// Convert the given value string to Int128 using the given radix
/// </summary>
internal override object FromString(string value, int radix)
{
Debug.Assert(radix == 16);
Debug.Assert(value is not null);
return(Int128.Parse(value, NumberStyles.HexNumber));
}
internal void Add(byte[] entropy, IEntropySource source)
{
// Determine how much of the packet will be accepted.
_CountOfBytesBySource.TryGetValue(source, out var countFromSource);
var bytesToaccept = BytesToAcceptFromSource(entropy.Length, countFromSource);
if (bytesToaccept <= 0)
{
// Ignoring this packet entirely.
return;
}
// Accumulate the packer into the hash function.
// Note that this may only incorporate part of the packet.
AccumulateBlock(entropy, bytesToaccept);
// Increment counters. Note that this may overflow for very long lived pools.
if (_CountOfBytesBySource.Count <= MaxSourcesToCount && countFromSource < Int32.MaxValue)
{
try
{
_CountOfBytesBySource[source] = countFromSource + bytesToaccept;
}
catch (OverflowException)
{
_CountOfBytesBySource[source] = Int32.MaxValue;
}
}
TotalEntropyBytes = TotalEntropyBytes + bytesToaccept;
EntropyBytesSinceLastDigest = EntropyBytesSinceLastDigest + bytesToaccept;
}
public void Int128Equality()
{
// Reflexivity a = a
// Symmetry a = b => b = a
// Transitivity a = b & b = c => a = c
Int128[] values = new Int128[] { Int128.MinValue, Int64.MinValue, Int32.MinValue, -Int128.One, Int128.Zero, Int128.One, Int64.MaxValue, Int128.MaxValue };
foreach (Int128 x in values)
{
Assert.IsTrue(x.Equals(x));
Assert.IsFalse(x.Equals(null));
foreach (Int128 y in values)
{
if (x == y)
{
Assert.IsTrue(y == x);
Assert.IsFalse(x != y);
Assert.IsTrue(y.Equals(x));
Assert.IsTrue(x.Equals((object)y));
Assert.IsTrue(x.GetHashCode() == y.GetHashCode());
}
else
{
Assert.IsTrue(x != y);
Assert.IsFalse(y.Equals(x));
Assert.IsFalse(x.Equals((object)y));
}
}
}
}
public void Int128Comparison()
{
Int128[] orderedValues = new Int128[] { Int128.MinValue, Int64.MinValue, Int32.MinValue, -Int128.One, Int128.Zero, Int128.One, Int32.MaxValue, Int64.MaxValue, Int128.MaxValue };
for (int i = 0; i < orderedValues.Length; i++)
{
for (int j = 0; j < orderedValues.Length; j++)
{
if (i < j)
{
Assert.IsTrue(Int128.Compare(orderedValues[i], orderedValues[j]) == -1);
Assert.IsTrue(orderedValues[i].CompareTo(orderedValues[j]) == -1);
Assert.IsTrue(orderedValues[i] < orderedValues[j]);
Assert.IsFalse(orderedValues[i] >= orderedValues[j]);
}
else if (i == j)
{
Assert.IsTrue(Int128.Compare(orderedValues[i], orderedValues[j]) == 0);
Assert.IsTrue(orderedValues[i].CompareTo(orderedValues[j]) == 0);
Assert.IsFalse(orderedValues[i] < orderedValues[j]);
Assert.IsFalse(orderedValues[i] > orderedValues[j]);
Assert.IsTrue(orderedValues[i] <= orderedValues[j]);
}
else
{
Assert.IsTrue(Int128.Compare(orderedValues[i], orderedValues[j]) == +1);
Assert.IsTrue(orderedValues[i].CompareTo(orderedValues[j]) == +1);
Assert.IsTrue(orderedValues[i] > orderedValues[j]);
Assert.IsFalse(orderedValues[i] <= orderedValues[j]);
}
}
}
}
public void Int128ParseFailure()
{
Assert.IsFalse(Int128.TryParse(null, out _));
Assert.ThrowsException <ArgumentNullException>(() => Int128.Parse(null));
Assert.IsFalse(Int128.TryParse(String.Empty, out _));
Assert.ThrowsException <FormatException>(() => Int128.Parse(String.Empty));
Assert.IsFalse(Int128.TryParse("1x2", out _));
Assert.ThrowsException <FormatException>(() => Int128.Parse("-1 2"));
// Max is parsable, but one more isn't.
Assert.IsTrue(Int128.TryParse(Int128.MaxValue.ToString(), out Int128 max));
Assert.IsTrue(max == Int128.MaxValue);
string oneOverMax = UInt128Test.MakeNumberOneBigger(Int128.MaxValue.ToString());
Assert.IsFalse(Int128.TryParse(oneOverMax, out _));
Assert.ThrowsException <OverflowException>(() => Int128.Parse(oneOverMax));
// Min is parsable, but one less isn't.
Assert.IsTrue(Int128.TryParse(Int128.MinValue.ToString(), out Int128 min));
Assert.IsTrue(min == Int128.MinValue);
string oneUnderMin = UInt128Test.MakeNumberOneBigger(Int128.MinValue.ToString());
Assert.IsFalse(Int128.TryParse(oneUnderMin, out _));
Assert.ThrowsException <OverflowException>(() => Int128.Parse(oneUnderMin));
}
public void Int128Int64Agreement()
{
Random rng = new Random(12864);
foreach (long u in GetRandomInt64(8, rng))
{
foreach (long v in GetRandomInt64(8, rng))
{
Int128 sum = ((Int128)u) + ((Int128)v);
long sum1 = u + v;
Assert.IsTrue((long)sum == sum1);
Int128 difference = ((Int128)u) - ((Int128)v);
long difference1 = u - v;
Assert.IsTrue((long)difference == difference1);
Int128 product = ((Int128)u) * ((Int128)v);
long product1 = u * v;
Assert.IsTrue((long)product == product1);
Int128 quotient = ((Int128)u) / ((Int128)v);
long quotient1 = u / v;
Assert.IsTrue((long)quotient == quotient);
}
}
}
public void Int128RandomArithmetic()
{
Random rng = new Random(314159);
foreach (Int128 x in GetRandomInt128(8, rng))
{
// Relation of addition to multiplication
Assert.IsTrue(-x == -1 * x);
Assert.IsTrue(0 == 0 * x);
Assert.IsTrue(x == 1 * x);
Assert.IsTrue(x + x == 2 * x);
Assert.IsTrue(x + x + x == 3 * x);
foreach (Int128 y in GetRandomInt128(8, rng))
{
// Subtraction and addition are inverses
Assert.IsTrue(y + (x - y) == x);
// Division methods agree
Int128 q = Int128.DivRem(x, y, out Int128 r);
Assert.IsTrue(q == x / y);
Assert.IsTrue(r == x % y);
// Division and multiplication are inverses
Assert.IsTrue(q * y + r == x);
}
}
}
public static void Parse_Valid(string value, NumberStyles style, IFormatProvider provider, Int128 expected)
{
Int128 result;
// Default style and provider
if ((style == NumberStyles.Integer) && (provider is null))
{
Assert.True(Int128.TryParse(value, out result));
Assert.Equal(expected, result);
Assert.Equal(expected, Int128.Parse(value));
}
// Default provider
if (provider is null)
{
Assert.Equal(expected, Int128.Parse(value, style));
// Substitute default NumberFormatInfo
Assert.True(Int128.TryParse(value, style, new NumberFormatInfo(), out result));
Assert.Equal(expected, result);
Assert.Equal(expected, Int128.Parse(value, style, new NumberFormatInfo()));
}
// Default style
if (style == NumberStyles.Integer)
{
Assert.Equal(expected, Int128.Parse(value, provider));
}
// Full overloads
Assert.True(Int128.TryParse(value, style, provider, out result));
Assert.Equal(expected, result);
Assert.Equal(expected, Int128.Parse(value, style, provider));
}
public static void ToString_InvalidFormat_ThrowsFormatException()
{
Int128 i = 123;
Assert.Throws <FormatException>(() => i.ToString("Y")); // Invalid format
Assert.Throws <FormatException>(() => i.ToString("Y", null)); // Invalid format
}
public static async Task <ResPq> Do(Int128 nonce, MtProtoPlainTransport transport)
{
var res = await transport.Call(new ReqPq(nonce)).ConfigureAwait(false);
Helpers.Assert(res.Nonce == nonce, "auth step1: invalid nonce");
return(res);
}
/// <summary>
/// Converts an <see cref="Int128" /> value to an array of bytes.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="buffer">An array of bytes.</param>
/// <param name="offset">The starting position within <paramref name="buffer" />.</param>
/// <param name="asLittleEndian">Convert from little endian.</param>
public static void ToBytes(this Int128 value, byte[] buffer, int offset = 0, bool?asLittleEndian = null)
{
bool ale = GetIsLittleEndian(asLittleEndian);
value.Low.ToBytes(buffer, ale ? offset : offset + 8, ale);
value.High.ToBytes(buffer, ale ? offset + 8 : offset, ale);
}
public static Int128 Int128Mul(long lhs, long rhs)
{
bool num = lhs < 0 != rhs < 0;
if (lhs < 0)
{
lhs = -lhs;
}
if (rhs < 0)
{
rhs = -rhs;
}
ulong num2 = (ulong)lhs >> 32;
ulong num3 = (ulong)(lhs & uint.MaxValue);
ulong num4 = (ulong)rhs >> 32;
ulong num5 = (ulong)(rhs & uint.MaxValue);
ulong num6 = num2 * num4;
ulong num7 = num3 * num5;
ulong num8 = num2 * num5 + num3 * num4;
long num9 = (long)(num6 + (num8 >> 32));
ulong num10 = (num8 << 32) + num7;
if (num10 < num7)
{
num9++;
}
Int128 @int = new Int128(num9, num10);
if (!num)
{
return(@int);
}
return(-@int);
}
public static void ToStringTest(Int128 i, string format, IFormatProvider provider, string expected)
{
// Format is case insensitive
string upperFormat = format.ToUpperInvariant();
string lowerFormat = format.ToLowerInvariant();
string upperExpected = expected.ToUpperInvariant();
string lowerExpected = expected.ToLowerInvariant();
bool isDefaultProvider = (provider is null) || (provider == NumberFormatInfo.CurrentInfo);
if (string.IsNullOrEmpty(format) || (format.ToUpperInvariant() is "G" or "R"))
{
if (isDefaultProvider)
{
Assert.Equal(upperExpected, i.ToString());
Assert.Equal(upperExpected, i.ToString((IFormatProvider)null));
}
Assert.Equal(upperExpected, i.ToString(provider));
}
if (isDefaultProvider)
{
Assert.Equal(upperExpected, i.ToString(upperFormat));
Assert.Equal(lowerExpected, i.ToString(lowerFormat));
Assert.Equal(upperExpected, i.ToString(upperFormat, null));
Assert.Equal(lowerExpected, i.ToString(lowerFormat, null));
}
Assert.Equal(upperExpected, i.ToString(upperFormat, provider));
Assert.Equal(lowerExpected, i.ToString(lowerFormat, provider));
}
public void JaegerActivityConverterTest_ConvertActivityToJaegerSpan_NoAttributes()
{
var activity = CreateTestActivity(setAttributes: false);
var traceIdAsInt = new Int128(activity.Context.TraceId);
var spanIdAsInt = new Int128(activity.Context.SpanId);
var linkTraceIdAsInt = new Int128(activity.Links.Single().Context.TraceId);
var linkSpanIdAsInt = new Int128(activity.Links.Single().Context.SpanId);
var jaegerSpan = activity.ToJaegerSpan();
Assert.Equal("Name", jaegerSpan.OperationName);
Assert.Equal(2, jaegerSpan.Logs.Count);
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
Assert.Equal(new Int128(activity.ParentSpanId).Low, jaegerSpan.ParentSpanId);
Assert.Equal(activity.Links.Count(), jaegerSpan.References.Count);
var references = jaegerSpan.References.ToArray();
var jaegerRef = references[0];
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
Assert.Equal(0x1, jaegerSpan.Flags);
Assert.Equal(activity.StartTimeUtc.ToEpochMicroseconds(), jaegerSpan.StartTime);
Assert.Equal((long)(activity.Duration.TotalMilliseconds * 1000), jaegerSpan.Duration);
// 2 tags: span.kind & library.name.
Assert.Equal(2, jaegerSpan.Tags.Count);
var logs = jaegerSpan.Logs.ToArray();
var jaegerLog = logs[0];
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
Assert.Equal(2, jaegerLog.Fields.Count());
var eventFields = jaegerLog.Fields.ToArray();
var eventField = eventFields[0];
Assert.Equal("key", eventField.Key);
Assert.Equal("value", eventField.VStr);
eventField = eventFields[1];
Assert.Equal("message", eventField.Key);
Assert.Equal("Event1", eventField.VStr);
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
jaegerLog = logs[1];
Assert.Equal(2, jaegerLog.Fields.Count());
eventFields = jaegerLog.Fields.ToArray();
eventField = eventFields[0];
Assert.Equal("key", eventField.Key);
Assert.Equal("value", eventField.VStr);
eventField = eventFields[1];
Assert.Equal("message", eventField.Key);
Assert.Equal("Event2", eventField.VStr);
}
/// <summary>
/// Gets the circumference of a closed polygon.
/// </summary>
/// <param name="closedPolygon">The closed polygon.</param>
/// <returns>The circumference of the given closed polygon.</returns>
public static double GetClosedPolygonCircumference(IEnumerable <IntPoint> closedPolygon)
{
IntPoint firstPoint = default;
IntPoint previous = default;
double sum = 0.0;
var numberOfPoints = 0;
foreach (var pt in closedPolygon)
{
if (0 == numberOfPoints)
{
firstPoint = pt;
}
else
{
sum += Math.Sqrt((double)(Int128.Int128Mul(pt.X - previous.X, pt.X - previous.X) + Int128.Int128Mul(pt.Y - previous.Y, pt.Y - previous.Y)));
}
previous = pt;
++numberOfPoints;
}
if (numberOfPoints == 0)
{
throw new ArgumentException("Polygon is empty (has no point at all)", nameof(closedPolygon));
}
else
{
var pt = firstPoint;
sum += Math.Sqrt((double)(Int128.Int128Mul(pt.X - previous.X, pt.X - previous.X) + Int128.Int128Mul(pt.Y - previous.Y, pt.Y - previous.Y)));
return(sum);
}
}
public override void DeserializeBody(BinaryReader br)
{
nonce = (Int128)ObjectUtils.DeserializeObject(br);
server_nonce = (Int128)ObjectUtils.DeserializeObject(br);
new_nonce_hash = (Int128)ObjectUtils.DeserializeObject(br);
Type = TLAbsServer_DH_ParamsTypes.TLServer_DH_params_fail;
}
/// <summary>
/// Initializes a new instance of the <see cref="Immediate"/> class.
/// </summary>
/// <param name="constant">A constant.</param>
/// <param name="size">The size of the resulting value.</param>
public Immediate(Int128 constant, DataSize size)
: this(c => new SimpleExpression(constant), size)
{
#region Contract
Contract.Requires <InvalidEnumArgumentException>(Enum.IsDefined(typeof(DataSize), size));
#endregion
}
public void JaegerSpanConverterTest_ConvertSpanToJaegerSpan_NoEvents()
{
var span = CreateTestSpan(addEvents: false);
var traceIdAsInt = new Int128(span.Context.TraceId);
var spanIdAsInt = new Int128(span.Context.SpanId);
var linkTraceIdAsInt = new Int128(span.Links.Single().Context.TraceId);
var linkSpanIdAsInt = new Int128(span.Links.Single().Context.SpanId);
var jaegerSpan = span.ToJaegerSpan();
Assert.Equal("Name", jaegerSpan.OperationName);
Assert.Empty(jaegerSpan.Logs);
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
Assert.Equal(new Int128(span.ParentSpanId).Low, jaegerSpan.ParentSpanId);
Assert.Equal(span.Links.Count(), jaegerSpan.References.Count);
var references = jaegerSpan.References.ToArray();
var jaegerRef = references[0];
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
Assert.Equal(0x1, jaegerSpan.Flags);
Assert.Equal(span.StartTimestamp.ToEpochMicroseconds(), jaegerSpan.StartTime);
Assert.Equal(
span.EndTimestamp.ToEpochMicroseconds()
- span.StartTimestamp.ToEpochMicroseconds(), jaegerSpan.Duration);
var tags = jaegerSpan.Tags.ToArray();
var tag = tags[0];
Assert.Equal(JaegerTagType.STRING, tag.VType);
Assert.Equal("stringKey", tag.Key);
Assert.Equal("value", tag.VStr);
tag = tags[1];
Assert.Equal(JaegerTagType.LONG, tag.VType);
Assert.Equal("longKey", tag.Key);
Assert.Equal(1, tag.VLong);
tag = tags[2];
Assert.Equal(JaegerTagType.LONG, tag.VType);
Assert.Equal("longKey2", tag.Key);
Assert.Equal(1, tag.VLong);
tag = tags[3];
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
Assert.Equal("doubleKey", tag.Key);
Assert.Equal(1, tag.VDouble);
tag = tags[4];
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
Assert.Equal("doubleKey2", tag.Key);
Assert.Equal(1, tag.VDouble);
tag = tags[5];
Assert.Equal(JaegerTagType.BOOL, tag.VType);
Assert.Equal("boolKey", tag.Key);
Assert.Equal(true, tag.VBool);
}
public static Int128 Power(Int128 value, Int128 exponent)
{
Int128 result;
Int128.Pow(out result, ref value, (int)exponent);
return(result);
}
public IMessage DecodeEncryptedMessage(byte[] messageBytes, byte[] authKey, Sender sender, out UInt64 salt, out UInt64 sessionId)
{
Argument.IsNotNull(() => authKey);
Argument.IsNotNull(() => messageBytes);
ulong providedAuthKeyId = ComputeAuthKeyId(authKey);
var encryptedData = new byte[messageBytes.Length - EncryptedOuterHeaderLength];
Int128 msgKey;
using (var streamer = new TLStreamer(messageBytes))
{
// Reading header.
ulong authKeyId = streamer.ReadUInt64();
if (authKeyId != providedAuthKeyId)
{
throw new InvalidAuthKey(string.Format("Message encrypted with auth key with id={0}, but auth key provided for decryption with id={1}.", authKeyId,
providedAuthKeyId));
}
msgKey = streamer.ReadInt128();
// Reading encrypted data.
streamer.Read(encryptedData, 0, encryptedData.Length);
}
// Decrypting.
byte[] aesKey, aesIV;
ComputeAesKeyAndIV(authKey, msgKey, out aesKey, out aesIV, sender);
byte[] innerDataWithPadding = _encryptionServices.Aes256IgeDecrypt(encryptedData, aesKey, aesIV);
Int32 msgDataLength;
UInt64 msgId;
UInt32 seqno;
Object body;
using (var streamer = new TLStreamer(innerDataWithPadding))
{
salt = streamer.ReadUInt64();
sessionId = streamer.ReadUInt64();
msgId = streamer.ReadUInt64();
seqno = streamer.ReadUInt32();
msgDataLength = streamer.ReadInt32();
body = _tlRig.Deserialize(streamer);
}
int innerDataLength = EncryptedInnerHeaderLength + msgDataLength;
// When an encrypted message is received, it must be checked that
// msg_key is in fact equal to the 128 lower-order bits
// of the SHA1 hash of the previously encrypted portion.
Int128 expectedMsgKey = ComputeMsgKey(new ArraySegment <byte>(innerDataWithPadding, 0, innerDataLength));
if (msgKey != expectedMsgKey)
{
throw new InvalidMessageException(string.Format("Expected message key to be {0}, but actual is {1}.", expectedMsgKey, msgKey));
}
return(new Message(msgId, seqno, body));
}
public void JaegerSpanConverterTest_ConvertSpanToJaegerSpan_NoAttributes()
{
var span = CreateTestSpan(setAttributes: false);
var traceIdAsInt = new Int128(span.Context.TraceId);
var spanIdAsInt = new Int128(span.Context.SpanId);
var linkTraceIdAsInt = new Int128(span.Links.Single().Context.TraceId);
var linkSpanIdAsInt = new Int128(span.Links.Single().Context.SpanId);
var jaegerSpan = span.ToJaegerSpan();
Assert.Equal("Name", jaegerSpan.OperationName);
Assert.Equal(2, jaegerSpan.Logs.Count());
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
Assert.Equal(new Int128(span.ParentSpanId).Low, jaegerSpan.ParentSpanId);
Assert.Equal(span.Links.Count(), jaegerSpan.References.Count());
var references = jaegerSpan.References.ToArray();
var jaegerRef = references[0];
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
Assert.Equal(0x1, jaegerSpan.Flags);
Assert.Equal(span.StartTimestamp.ToEpochMicroseconds(), jaegerSpan.StartTime);
Assert.Equal((long)((span.EndTimestamp - span.StartTimestamp).TotalMilliseconds * 1000), jaegerSpan.Duration);
// A single tag representing the span.kind
Assert.Single(jaegerSpan.JaegerTags);
var logs = jaegerSpan.Logs.ToArray();
var jaegerLog = logs[0];
Assert.Equal(span.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
Assert.Equal(2, jaegerLog.Fields.Count());
var eventFields = jaegerLog.Fields.ToArray();
var eventField = eventFields[0];
Assert.Equal("key", eventField.Key);
Assert.Equal("value", eventField.VStr);
eventField = eventFields[1];
Assert.Equal("message", eventField.Key);
Assert.Equal("Event1", eventField.VStr);
Assert.Equal(span.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
jaegerLog = logs[1];
Assert.Equal(2, jaegerLog.Fields.Count());
eventFields = jaegerLog.Fields.ToArray();
eventField = eventFields[0];
Assert.Equal("key", eventField.Key);
Assert.Equal("value", eventField.VStr);
eventField = eventFields[1];
Assert.Equal("message", eventField.Key);
Assert.Equal("Event2", eventField.VStr);
}
/// <summary>
/// Initializes a new instance of the <see cref="Immediate"/> class.
/// </summary>
/// <param name="constant">A constant.</param>
/// <param name="size">The size of the resulting value.</param>
public Immediate(Int128 constant, DataSize size)
: this(c => new SimpleExpression(constant), size)
{
#region Contract
Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(DataSize), size));
#endregion
}
public override void DeserializeBody(BinaryReader br)
{
nonce = (Int128)ObjectUtils.DeserializeObject(br);
server_nonce = (Int128)ObjectUtils.DeserializeObject(br);
new_nonce_hash2 = (Int128)ObjectUtils.DeserializeObject(br);
Type = TLAbsSet_client_DH_params_answerTypes.TLDh_gen_retry;
}
// nb: Constructing two new Int128 objects every time we want to multiply longs
// is slow. So, although calling the Int128Mul method doesn't look as clean, the
// code runs significantly faster than if we'd used the * operator.
public static Int128 Int128Mul(long lhs, long rhs)
{
var negate = lhs < 0 != rhs < 0;
if (lhs < 0)
{
lhs = -lhs;
}
if (rhs < 0)
{
rhs = -rhs;
}
var int1Hi = (ulong)lhs >> 32;
var int1Lo = (ulong)lhs & 0xFFFFFFFF;
var int2Hi = (ulong)rhs >> 32;
var int2Lo = (ulong)rhs & 0xFFFFFFFF;
// nb: see comments in clipper.pas
var a = int1Hi * int2Hi;
var b = int1Lo * int2Lo;
var c = int1Hi * int2Lo + int1Lo * int2Hi;
ulong lo;
var hi = (long)(a + (c >> 32));
unchecked { lo = (c << 32) + b; }
if (lo < b)
{
hi++;
}
var result = new Int128(hi, lo);
return(negate ? -result : result);
}
public static Int128 operator +(Int128 val1, int val2)
{
if (val1 == 0)
{
return(new Int128((uint)val2));
}
if (val2 == 0)
{
return(val1);
}
Int128 ret = new Int128(0);
ulong sum = 0;
sum = val1._x0 + (ulong)val2 + sum;
ret._x0 = (uint)sum;
sum >>= 32;
sum = val1._x1 + sum;
ret._x1 = (uint)sum;
sum >>= 32;
sum = val1._x2 + sum;
ret._x2 = (uint)sum;
sum >>= 32;
sum = val1._x3 + sum;
ret._x3 = (uint)sum;
return(ret);
}
private static void TestMul6464(long a, long b, ulong highExpected, ulong lowExpected)
{
Int128 product = Int128.Mul(a, b);
Assert.AreEqual(highExpected, product.High);
Assert.AreEqual(lowExpected, product.Low);
}
public static Int128 Align(Int128 value, int boundary)
{
#region Contract
Contract.Requires<ArgumentOutOfRangeException>(boundary >= 1);
Contract.Requires<ArgumentException>(IsPowerOfTwo(boundary));
Contract.Ensures(Contract.Result<Int128>() >= value);
#endregion
return (boundary + ((value - 1) & ~(boundary - 1)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Relocation"/> class.
/// </summary>
/// <param name="symbol">The target symbol.</param>
/// <param name="section">The section in which the storage unit to be relocated resides.</param>
/// <param name="offset">The offset relative to the start of <paramref name="section"/> at which the storage
/// unit to be relocated resides.</param>
/// <param name="addend">The constant used to compute the value of the relocatable field.</param>
/// <param name="type">The type of relocation compution to perform.</param>
public Relocation(Symbol symbol, Section section, Int128 offset, Int128 addend, RelocationType type)
{
#region Contract
Contract.Requires<ArgumentNullException>(symbol != null);
Contract.Requires<ArgumentNullException>(section != null);
#endregion
this.targetSymbol = symbol;
this.section = section;
this.offset = offset;
this.addend = addend;
this.type = type;
}
/// <summary>
/// Writes a 128-bit value to the <see cref="BinaryWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="BinaryWriter"/> to write to.</param>
/// <param name="value">The value to write.</param>
public static void Write(this BinaryWriter writer, Int128 value)
{
#region Contract
Contract.Requires<ArgumentNullException>(writer != null);
#endregion
// We maintain the same byte ordering as the BinaryWriter.
if (BitConverter.IsLittleEndian)
{
writer.Write((ulong)value.Low);
writer.Write((ulong)value.High);
}
else
{
writer.Write((ulong)value.High);
writer.Write((ulong)value.Low);
}
}
public static void Serialize(Int128 src, BinaryWriter writer)
{
writer.Write(src.ToBytes(true));
}
void StartFight(Int128 guid)
{
Thread.Sleep(100);
var t = new Thread(StartFightNewThead) {Name = "StartFightNewThead(object guid)"};
t.Start(guid);
Thread.Sleep(1000);
}
public Guid(Int128 guid)
{
_mGuid = guid;
}
public static void GetPrimeMultipliers(this Int128 pq, out Int128 p, out Int128 q)
{
var pq256 = (Int256) pq;
Int256 p256, q256;
pq256.GetPrimeMultipliers(out p256, out q256);
p = (Int128) p256;
q = (Int128) q256;
}
public static Int128 Square(Int128 a)
{
return Int128.Square(a);
}
/// <summary>
/// Resets this context without clearing the symbol or relocation tables.
/// </summary>
/// <remarks>
/// The context's address is reset to zero, the curent section is set to <see langword="null"/>. Derived
/// classes may override this method and reset other fields and properties. The symbol and relocation tables
/// are never cleared.
/// </remarks>
public virtual void Reset()
{
this.address = 0;
this.section = null;
}
public static DataSize GetSizeOfValue(Int128 value)
{
#region Contract
Contract.Ensures(Enum.IsDefined(typeof(DataSize), Contract.Result<DataSize>()));
#endregion
return GetSizeOfValue(value, true);
}
public static bool IsPowerOfTwo(Int128 a)
{
return a.IsPowerOfTwo;
}
public WowGuid(Int128 guid)
{
m_guid = guid;
}
public static Int128 Max(Int128 a, Int128 b)
{
return Int128.Max(a, b);
}
public static Int128 Min(Int128 a, Int128 b)
{
return Int128.Min(a, b);
}
public static Int128 TwosComplement(Int128 a)
{
return -a;
}
public static Int128 CalculatePadding(Int128 value, int boundary)
{
#region Contract
Contract.Requires<ArgumentOutOfRangeException>(boundary >= 1);
Contract.Requires<ArgumentException>(IsPowerOfTwo(boundary));
Contract.Ensures(Contract.Result<Int128>() >= 0);
#endregion
return Align(value, boundary) - value;
}
public List<CrawlTaskDetail> List = new List<CrawlTaskDetail>(); //任务列表
#endregion Fields
#region Constructors
public CrawlTask()
{
ID = new Int128(Guid.NewGuid().ToByteArray());
CreateDt = DateTime.Now;
WorkTimeSpan = 60;
}
public static DataSize GetSizeOfValue(Int128 value, bool signed)
{
#region Contract
Contract.Ensures(Enum.IsDefined(typeof(DataSize), Contract.Result<DataSize>()));
#endregion
if (signed && value < 0)
value = -value;
if (value.High != 0) return DataSize.Bit128;
if ((value.Low & 0xFFFFFFFF00000000) != 0) return DataSize.Bit64;
if ((value.Low & 0x00000000FFFF0000) != 0) return DataSize.Bit32;
if ((value.Low & 0x000000000000FF00) != 0) return DataSize.Bit16;
return DataSize.Bit8;
}
/// <summary>
/// Defines the symbol by setting its value and adding it to the symbol table.
/// </summary>
/// <param name="context">The current <see cref="Context"/>.</param>
/// <param name="value">The value of the symbol.</param>
public void Define(Context context, Int128 value)
{
#region Contract
Contract.Requires<ArgumentNullException>(context != null);
#endregion
this.Value = value;
this.DefiningSection = context.Section;
this.DefiningFile = context.Section.Parent;
context.SymbolTable.Add(this);
}
public static Int128 GCD(this Int128 a, Int128 b)
{
while (true)
{
if (b == 0)
{
return a;
}
Int128 a1 = a;
a = b;
b = a1%b;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Immediate"/> class.
/// </summary>
/// <param name="constant">A constant.</param>
public Immediate(Int128 constant)
: this(constant, DataSize.None)
{
}
public static Int128 Power(Int128 value, Int128 exponent)
{
Int128 result;
Int128.Pow(out result, ref value, (int)exponent);
return result;
}
private void ComputeAesKeyAndIV(byte[] authKey, Int128 msgKey, out byte[] aesKey, out byte[] aesIV, Sender sender)
{
// x = 0 for messages from client to server and x = 8 for those from server to client.
int x;
switch (sender)
{
case Sender.Client:
x = 0;
break;
case Sender.Server:
x = 8;
break;
default:
throw new ArgumentOutOfRangeException("sender");
}
byte[] msgKeyBytes = msgKey.ToBytes();
byte[] buffer = _aesKeyAndIVComputationBuffer ?? (_aesKeyAndIVComputationBuffer = new byte[32 + MsgKeyLength]);
// sha1_a = SHA1 (msg_key + substr (auth_key, x, 32));
Buffer.BlockCopy(msgKeyBytes, 0, buffer, 0, MsgKeyLength);
Buffer.BlockCopy(authKey, x, buffer, MsgKeyLength, 32);
byte[] sha1A = _hashServices.ComputeSHA1(buffer);
// sha1_b = SHA1 (substr (auth_key, 32+x, 16) + msg_key + substr (auth_key, 48+x, 16));
Buffer.BlockCopy(authKey, 32 + x, buffer, 0, 16);
Buffer.BlockCopy(msgKeyBytes, 0, buffer, 16, MsgKeyLength);
Buffer.BlockCopy(authKey, 48 + x, buffer, 16 + MsgKeyLength, 16);
byte[] sha1B = _hashServices.ComputeSHA1(buffer);
// sha1_с = SHA1 (substr (auth_key, 64+x, 32) + msg_key);
Buffer.BlockCopy(authKey, 64 + x, buffer, 0, 32);
Buffer.BlockCopy(msgKeyBytes, 0, buffer, 32, MsgKeyLength);
byte[] sha1C = _hashServices.ComputeSHA1(buffer);
// sha1_d = SHA1 (msg_key + substr (auth_key, 96+x, 32));
Buffer.BlockCopy(msgKeyBytes, 0, buffer, 0, MsgKeyLength);
Buffer.BlockCopy(authKey, 96 + x, buffer, MsgKeyLength, 32);
byte[] sha1D = _hashServices.ComputeSHA1(buffer);
// aes_key = substr (sha1_a, 0, 8) + substr (sha1_b, 8, 12) + substr (sha1_c, 4, 12);
aesKey = new byte[32];
Buffer.BlockCopy(sha1A, 0, aesKey, 0, 8);
Buffer.BlockCopy(sha1B, 8, aesKey, 8, 12);
Buffer.BlockCopy(sha1C, 4, aesKey, 20, 12);
// aes_iv = substr (sha1_a, 8, 12) + substr (sha1_b, 0, 8) + substr (sha1_c, 16, 4) + substr (sha1_d, 0, 8);
aesIV = new byte[32];
Buffer.BlockCopy(sha1A, 8, aesIV, 0, 12);
Buffer.BlockCopy(sha1B, 0, aesIV, 12, 8);
Buffer.BlockCopy(sha1C, 16, aesIV, 20, 4);
Buffer.BlockCopy(sha1D, 0, aesIV, 24, 8);
}
/// <summary>
/// Writes a value to the <see cref="BinaryWriter"/> as a value with the specified size.
/// </summary>
/// <param name="writer">The <see cref="BinaryWriter"/> to write to.</param>
/// <param name="value">The value to write.</param>
/// <param name="size">The size of the value to write.</param>
/// <returns>The number of written bytes.</returns>
public static int Write(this BinaryWriter writer, Int128 value, DataSize size)
{
#region Contract
Contract.Requires<ArgumentNullException>(writer != null);
Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(DataSize), size));
Contract.Requires<ArgumentException>(size != DataSize.None);
Contract.Ensures(Contract.Result<int>() >= 0);
#endregion
switch (size)
{
case DataSize.Bit8:
case DataSize.Bit16:
case DataSize.Bit32:
case DataSize.Bit64:
case DataSize.Bit80:
writer.Write((ulong)value, size);
break;
case DataSize.Bit128:
writer.Write(value);
break;
case DataSize.Bit256:
// We maintain the same byte ordering as the BinaryWriter.
if (BitConverter.IsLittleEndian)
{
writer.Write(value);
writer.Write((Int128)0);
}
else
{
writer.Write((Int128)0);
writer.Write(value);
}
break;
default:
throw new NotSupportedException();
}
return (int)size;
}
private bool CheckNewNonceHash(Int256 newNonce, Int128 newNonceHash)
{
byte[] hash = ComputeSHA1(newNonce.ToBytes());
Int128 nonceHash = hash.ToInt128();
return nonceHash == newNonceHash;
}
public override void WriteInt128(Int128 value)
{
lock (_streamer)
_streamer.WriteInt128(value);
}
private void CheckNonce(Int128 expectedNonce, Int128 actualNonce)
{
if (actualNonce != expectedNonce)
{
throw new InvalidResponseException(string.Format("Expected nonce {0:X16} differs from the actual nonce {1:X16}.", expectedNonce, actualNonce));
}
}
public static Int128 Modulus(Int128 n, Int128 p)
{
var result = n % p;
if (result < 0)
result += p;
return result;
}
public static Int128 Abs(Int128 a)
{
return a.IsNegative ? -a : a;
}
