public void TestCopyTo_EmptyArraySegment()
{
var array = new int[] { 1 };
var target = new ArraySegment <int>(array, 0, 0);
var result = new int[5];
Assert.That(target.CopyTo(0, result, 0, 1), Is.EqualTo(0));
}
public void TestCopyTo_EmptySourceArray()
{
var array = new int[0];
var target = new ArraySegment <int>(array);
var result = new int[5];
Assert.That(target.CopyTo(0, result, 0, 1), Is.EqualTo(0));
}
[NotNull] internal static T[] ToArray <T>(this ArraySegment <T> segment)
where T : struct
{
var arr = new T[segment.Count];
segment.CopyTo(arr);
return(arr);
}
/// <summary>
/// Write some bytes into the underlying array. Mutate this writer to represent the position after the write. </summary>
/// <param name="data">data to write</param>
/// <returns>A copy of this writer (after the write has been applied)</returns>
public PacketWriter Write(ArraySegment <byte> data)
{
Write((ushort)data.Count);
data.CopyTo(_array.Array, _array.Offset + _count);
_count += data.Count;
return(this);
}
async ValueTask <int> SendThenBufferAsync(ArraySegment <byte> buffer)
{
await WriteAsync(_sendBuffer).ConfigureAwait(false);
buffer.CopyTo(_sendBuffer);
_sendBufferFillLength = buffer.Count;
return(0);
}
/// <summary>
/// Creates a new array containing the elements in this array segment.
/// </summary>
/// <typeparam name="T">The type of elements contained in the array.</typeparam>
/// <param name="segment">The array segment.</param>
/// <returns>The new array.</returns>
public static T[] ToArray <T>(this ArraySegment <T> segment)
{
Contract.Ensures(Contract.Result <T[]>() != null);
Contract.Ensures(Contract.Result <T[]>().Length == segment.Count);
var ret = new T[segment.Count];
segment.CopyTo(ret);
return(ret);
}
public async Task HandleWithCancellationTest()
{
// Arrange
var buffer = DockerFraming.Frame(TestLogTexts);
string id = "m1";
var runtimeInfoProvider = new Mock <IRuntimeInfoProvider>();
runtimeInfoProvider.Setup(r => r.GetModuleLogs(id, true, Option.None <int>(), Option.None <string>(), Option.None <string>(), Option.None <bool>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new MemoryStream(buffer));
runtimeInfoProvider.Setup(r => r.GetModules(It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { new ModuleRuntimeInfo(id, "docker", ModuleStatus.Running, "foo", 0, Option.None <DateTime>(), Option.None <DateTime>()) });
var logsProcessor = new LogsProcessor(new LogMessageParser("testIotHub", "d1"));
var logsProvider = new LogsProvider(runtimeInfoProvider.Object, logsProcessor);
var logRequestItem = new LogRequestItem(id, ModuleLogFilter.Empty);
var logsStreamRequest = new LogsStreamRequest("1.0", new List <LogRequestItem> {
logRequestItem
}, LogsContentEncoding.None, LogsContentType.Text);
byte[] logsStreamRequestBytes = logsStreamRequest.ToBytes();
var logsStreamRequestArraySeg = new ArraySegment <byte>(logsStreamRequestBytes);
var clientWebSocket = new Mock <IClientWebSocket>();
clientWebSocket.Setup(c => c.ReceiveAsync(It.IsAny <ArraySegment <byte> >(), It.IsAny <CancellationToken>()))
.Callback <ArraySegment <byte>, CancellationToken>((a, c) => logsStreamRequestArraySeg.CopyTo(a))
.ReturnsAsync(new WebSocketReceiveResult(logsStreamRequestBytes.Length, WebSocketMessageType.Binary, true));
var receivedBytes = new List <byte>();
clientWebSocket.Setup(c => c.SendAsync(It.IsAny <ArraySegment <byte> >(), WebSocketMessageType.Binary, true, It.IsAny <CancellationToken>()))
.Callback <ArraySegment <byte>, WebSocketMessageType, bool, CancellationToken>((a, w, f, c) => receivedBytes.AddRange(a.Array))
.Returns(async() => await Task.Delay(TimeSpan.FromSeconds(3)));
clientWebSocket.SetupGet(c => c.State).Returns(WebSocketState.Open);
// Act
var logsStreamRequestHandler = new LogsStreamRequestHandler(logsProvider, runtimeInfoProvider.Object);
Task handleTask = logsStreamRequestHandler.Handle(clientWebSocket.Object, CancellationToken.None);
await Task.Delay(TimeSpan.FromSeconds(10));
clientWebSocket.SetupGet(c => c.State).Returns(WebSocketState.Closed);
// Assert
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.True(handleTask.IsCompleted);
runtimeInfoProvider.VerifyAll();
clientWebSocket.VerifyAll();
Assert.True(receivedBytes.Count < buffer.Length);
IList <string> receivedChunks = SimpleFraming.Parse(receivedBytes.ToArray())
.Select(r => Encoding.UTF8.GetString(r))
.ToList();
Assert.Equal(TestLogTexts.Take(receivedChunks.Count), receivedChunks);
}
public void TestCopyTo_SmallArray()
{
var array = new int[] { 1, 2, 3 };
var target = new ArraySegment <int>(array);
var result = new int[2];
Assert.That(target.CopyTo(0, result, 0, result.Length), Is.EqualTo(2));
Assert.That(result, Is.EqualTo(new int[] { 1, 2 }));
}
/// <summary>
/// Write some bytes into the underlying array. Mutate this writer to represent the position after the write. </summary>
/// <param name="data">data to write</param>
/// <returns>A copy of this writer (after the write has been applied)</returns>
public PacketWriter Write(ArraySegment <byte> data)
{
Write((ushort)data.Count);
// ReSharper disable once AssignNullToNotNullAttribute (Justification: Array segment cannot be null)
data.CopyTo(_array.Array, _array.Offset + _count);
_count += data.Count;
return(this);
}
public void IList_CopyTo()
{
var array = new long[] { 1, 2, 3, 4, 5, 6, -10 };
IList <long> s = new ArraySegment <long> (array, 2, 3);
long[] target = new long[s.Count];
s.CopyTo(target, 0);
Assert.AreEqual(3, target[0], "#1");
Assert.AreEqual(4, target[1], "#2");
}
/// <summary>
/// Simulates copying to the send buffer; what you would do for user's content buffers.
/// </summary>
ValueTask <int> WriteBufferedAsync(ArraySegment <byte> buffer, bool flush = false)
{
int available = _sendBuffer.Length - _sendBufferFillLength;
if (available > buffer.Count && !flush)
{
buffer.CopyTo(_sendBuffer, _sendBufferFillLength);
_sendBufferFillLength += buffer.Count;
return(new ValueTask <int>(0));
}
if (_sendBufferFillLength == 0)
{
return(WriteAsync(buffer));
}
if (available > buffer.Count)
{
buffer.CopyTo(_sendBuffer, _sendBufferFillLength);
int sendLen = _sendBufferFillLength + buffer.Count;
_sendBufferFillLength = 0;
return(WriteAsync(_sendBuffer.AsMemory(0, sendLen)));
}
if (!flush)
{
int remainingBufferLength = buffer.Count - available;
if (remainingBufferLength < _sendBuffer.Length)
{
buffer.AsSpan(0, available).CopyTo(_sendBuffer.AsSpan(_sendBufferFillLength));
return(SendThenBufferAsync(buffer.Slice(available)));
}
}
return(SendThenSendAsync(buffer));
}
public async Task HandleTest()
{
// Arrange
var random = new Random();
var buffer = new byte[1024 * 128];
random.NextBytes(buffer);
string id = "m1";
var runtimeInfoProvider = new Mock <IRuntimeInfoProvider>();
runtimeInfoProvider.Setup(r => r.GetModuleLogs(id, true, Option.None <int>(), Option.None <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new MemoryStream(buffer));
runtimeInfoProvider.Setup(r => r.GetModules(It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { new ModuleRuntimeInfo(id, "docker", ModuleStatus.Running, "foo", 0, Option.None <DateTime>(), Option.None <DateTime>()) });
var logsProvider = new LogsProvider(runtimeInfoProvider.Object, Mock.Of <ILogsProcessor>());
var logRequestItem = new LogRequestItem(id, ModuleLogFilter.Empty);
var logsStreamRequest = new LogsStreamRequest("1.0", new List <LogRequestItem> {
logRequestItem
}, LogsContentEncoding.None, LogsContentType.Text);
byte[] logsStreamRequestBytes = logsStreamRequest.ToBytes();
var logsStreamRequestArraySeg = new ArraySegment <byte>(logsStreamRequestBytes);
var clientWebSocket = new Mock <IClientWebSocket>();
clientWebSocket.Setup(c => c.ReceiveAsync(It.IsAny <ArraySegment <byte> >(), It.IsAny <CancellationToken>()))
.Callback <ArraySegment <byte>, CancellationToken>((a, c) => logsStreamRequestArraySeg.CopyTo(a))
.Returns(
async() =>
{
await Task.Yield();
return(new WebSocketReceiveResult(logsStreamRequestBytes.Length, WebSocketMessageType.Binary, true));
});
var receivedBytes = new List <byte>();
clientWebSocket.Setup(c => c.SendAsync(It.IsAny <ArraySegment <byte> >(), WebSocketMessageType.Binary, true, It.IsAny <CancellationToken>()))
.Callback <ArraySegment <byte>, WebSocketMessageType, bool, CancellationToken>((a, w, f, c) => receivedBytes.AddRange(a.Array))
.Returns(async() => await Task.Yield());
clientWebSocket.SetupGet(c => c.State).Returns(WebSocketState.Open);
// Act
var logsStreamRequestHandler = new LogsStreamRequestHandler(logsProvider);
await logsStreamRequestHandler.Handle(clientWebSocket.Object, CancellationToken.None);
// Assert
runtimeInfoProvider.VerifyAll();
clientWebSocket.VerifyAll();
Assert.Equal(buffer, receivedBytes.ToArray());
}
public T Deserialize <T>(ArraySegment <byte> input)
{
byte[] rent = ArrayPool <byte> .Shared.Rent(input.Count);
try
{
input.CopyTo(rent);
return(JsonSerializer.Deserialize <T>(rent));
}
finally
{
ArrayPool <byte> .Shared.Return(rent);
}
}
public void TestCopyTo()
{
var array = new int[] { 1, 2, 3, 4, 5 };
var target = new ArraySegment<int>( array, 1, 3 );
var result = new int[ 5 ];
// Copy all
Assert.That( target.CopyTo( 0, result, 0, result.Length ), Is.EqualTo( target.Count ) );
Assert.That( result, Is.EqualTo( new int[] { 2, 3, 4, 0, 0 } ) );
// Source offset
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 1, result, 0, result.Length ), Is.EqualTo( target.Count - 1 ) );
Assert.That( result, Is.EqualTo( new int[] { 3, 4, 0, 0, 0 } ) );
// Offset
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 0, result, 1, result.Length ), Is.EqualTo( target.Count ) );
Assert.That( result, Is.EqualTo( new int[] { 0, 2, 3, 4, 0 } ) );
// Length
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 0, result, 0, result.Length - 1 ), Is.EqualTo( target.Count ) );
Assert.That( result, Is.EqualTo( new int[] { 2, 3, 4, 0, 0 } ) );
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 0, result, 0, target.Count - 1 ), Is.EqualTo( target.Count - 1 ) );
Assert.That( result, Is.EqualTo( new int[] { 2, 3, 0, 0, 0 } ) );
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 0, result, 0, 0 ), Is.EqualTo( 0 ) );
Assert.That( result, Is.EqualTo( new int[] { 0, 0, 0, 0, 0 } ) );
Array.Clear( result, 0, result.Length );
Assert.That( target.CopyTo( 0, result, 0, 1 ), Is.EqualTo( 1 ) );
Assert.That( result, Is.EqualTo( new int[] { 2, 0, 0, 0, 0 } ) );
}
public static void TestIList_CopyTo_Invalid()
{
IList <int> iList = new ArraySegment <int>();
Assert.Throws <InvalidOperationException>(() => iList.CopyTo(new int[7], 0)); // Array is null
var intArray = new int[] { 7, 8, 9, 10, 11, 12, 13 };
iList = new ArraySegment <int>(intArray, 2, 3);
Assert.Throws <ArgumentNullException>("dest", () => iList.CopyTo(null, 0)); // Destination array is null
Assert.Throws <ArgumentOutOfRangeException>("dstIndex", () => iList.CopyTo(new int[7], -1)); // Index < 0
Assert.Throws <ArgumentException>("", () => iList.CopyTo(new int[7], 8)); // Index > destinationArray.Length
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
lock (sendingSemaphore)
{
if (!endOfMessage)
{
throw new InvalidOperationException("Only completed messages are supported.");
}
var message = XdrBufferFactory.Rent(buffer.Count);
var segment = message.AsSegment(0, buffer.Count);
buffer.CopyTo(segment);
message.Resize(buffer.Count);
secondPartyPendingMessages.Add(new TestMessage(message, messageType, endOfMessage));
}
return(Task.CompletedTask);
}
public void CopyTo(T[] array, int arrayIndex)
{
if (array is null)
{
throw new ArgumentNullException(nameof(array));
}
if (arrayIndex <= 0)
{
throw new ArgumentOutOfRangeException(nameof(arrayIndex), "Is less than 0.");
}
if (array.Length - arrayIndex < Count)
{
throw new ArgumentException("The number of elements in the source ICollection<T> is greater than the available space from arrayIndex to the end of the destination array.");
}
_seg0.CopyTo(array, arrayIndex);
_seg1.CopyTo(array, arrayIndex + _seg0.Count);
}
public static X509Extension MakeAuthorityKey(this X509SubjectKeyIdentifierExtension subjectKeyIdentifierExtension)
{
// Make the AuthorityKeyIdentifierExtension. There is no built-in
// support, so it needs to be copied from the Subject Key
// Identifier of the signing certificate and massaged slightly.
// AuthorityKeyIdentifier is "KeyID=<subject key identifier>"
var issuerSubjectKey = subjectKeyIdentifierExtension.RawData;
var segment = new ArraySegment <byte>(issuerSubjectKey, 2, issuerSubjectKey.Length - 2);
var authorityKeyIdentifier = new byte[segment.Count + 4];
// these bytes define the "KeyID" part of the AuthorityKeyIdentifier
authorityKeyIdentifier[0] = 0x30;
authorityKeyIdentifier[1] = 0x16;
authorityKeyIdentifier[2] = 0x80;
authorityKeyIdentifier[3] = 0x14;
segment.CopyTo(authorityKeyIdentifier, 4);
return(new X509Extension("2.5.29.35", authorityKeyIdentifier, false));
}
internal bool PreprocessPacketToClient(ArraySegment <byte> packet, HlapiConn destination)
{
if (base.Server == null)
{
throw this.Log.CreatePossibleBugException("server packet preprocessing running, but this peer is not a server", "8f9dc0a0-1b48-4a7f-9bb6-f767b2542ab1");
}
if (base.Client == null)
{
return(false);
}
if (NetworkManager.singleton.client.connection != destination.Connection)
{
return(false);
}
if (base.Client != null)
{
this._loopbackQueue.Add(packet.CopyTo(this._loopbackBuffers.Get(), 0));
}
return(true);
}
private void Test5()
{
int[] ii = Enumerable.Range(1, 1_000_000).ToArray();
long total = 0;
int simdLongLength = Vector <long> .Count;
int simdIntLength = Vector <int> .Count;
int[] inu = new ArraySegment <int>(ii, 0, simdIntLength).ToArray();
var vInu = new Vector <int>(inu);
var tako = new ArraySegment <int>(ii, 0, simdIntLength);
var vTako = new Vector <int>(tako);
//var neko = new ArraySegment<long>(nums, 0, simdLongLength);//エラー型が違う
var neko = new long[simdLongLength];
//Array.ConstrainedCopy(ii, 1, neko, 0, 8);//エラー
for (int i = 0; i < simdLongLength; i++)
{
neko[i] = ii[i];
}
var uma = new long[ii.Length];
ii.CopyTo(uma, 0);
int[] iii = new ArraySegment <int>(ii, 10, simdLongLength).ToArray();
long[] ll = new long[simdLongLength];
iii.CopyTo(ll, 0);
int[] mm = ii.Skip(10).Take(simdLongLength).ToArray();
long[] nn = new long[simdLongLength];
mm.CopyTo(nn, 0);
int[] sp = new Span <int>(ii, 10, simdLongLength).ToArray();
long[] oo = new long[simdLongLength];
sp.CopyTo(oo, 0);
long[] pp = new long[simdLongLength];
new Span <int>(ii, 10, simdLongLength).ToArray().CopyTo(pp, 0);
}
/// <summary>
/// Create a new <see cref="Ulid"/> with the specified timestamp.
/// </summary>
/// <param name="timestamp">
/// Timestamp to use.
/// </param>
/// <returns>
/// An <see cref="Ulid"/> with the specified timestamp and cryptographically randomness.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="timestamp"/> is less than <see cref="MinTimestamp"/> or greater than <see cref="MaxTimestamp"/>.
/// </exception>
/// <exception cref="OverflowException">
/// <paramref name="timestamp"/> is the same as the last generated value and the randomness incrementing is overflow.
/// </exception>
public static Ulid Generate(long timestamp)
{
if (timestamp < MinTimestamp || timestamp > MaxTimestamp)
{
throw new ArgumentOutOfRangeException(nameof(timestamp));
}
//https://github.com/ulid/spec#monotonicity
//When generating a ULID within the same millisecond, we can provide some guarantees regarding sort order.
//Namely, if the same millisecond is detected, the random component is incremented by 1 bit in the least
//significant bit position (with carrying)
if (timestamp == LatestTimeStamp)
{
LatestRandomness++;
}
else
{
LatestTimeStamp = timestamp;
LatestRandomness = RandomLong(0, long.MaxValue);
}
byte[] timestampBytes = BitConverter.GetBytes(LatestTimeStamp);
Array.Reverse(timestampBytes);
timestampBytes = new ArraySegment <byte>(timestampBytes, 2, 6).ToArray();
//find randomness
byte[] randomness = BitConverter.GetBytes(LatestRandomness);
Array.Reverse(randomness);
byte[] finalRandomness = new byte[10];
randomness.CopyTo(finalRandomness, 2);
byte[] finalId = new byte[finalRandomness.Length + timestampBytes.Length];
timestampBytes.CopyTo(finalId, 0);
finalRandomness.CopyTo(finalId, timestampBytes.Length);
return(new Ulid(finalId));
}
private void ROMix(ArraySegment <byte> B, byte[] X, byte[] Y, byte[] V)
{
B.CopyTo(X, 0);
for (int i = 0; i < Cost; ++i)
{
Array.Copy(X, 0, V, i * (128 * BlockSize), 128 * BlockSize);
BlockMix(X, Y);
}
for (int i = 0; i < Cost; ++i)
{
ulong j = BitConverter.ToUInt64(X, (2 * BlockSize - 1) * 64);
j %= (ulong)Cost;
for (int k = 0; k < 128 * BlockSize; ++k)
{
X[k] ^= V[j * (128 * (ulong)BlockSize) + (ulong)k];
}
BlockMix(X, Y);
}
ArraySegment <byte> .Copy(X, B, 128 *BlockSize);
}
public static void TestIList_CopyTo()
{
var stringArray = new string[] { "0", "1", "2", "3", "4" };
IList <string> stringSegment = new ArraySegment <string>(stringArray, 1, 3);
stringSegment.CopyTo(stringArray, 2);
Assert.Equal(new string[] { "0", "1", "1", "2", "3" }, stringArray);
stringArray = new string[] { "0", "1", "2", "3", "4" };
stringSegment = new ArraySegment <string>(stringArray, 1, 3);
stringSegment.CopyTo(stringArray, 0);
Assert.Equal(new string[] { "1", "2", "3", "3", "4" }, stringArray);
var intArray = new int[] { 0, 1, 2, 3, 4 };
IList <int> intSegment = new ArraySegment <int>(intArray, 1, 3);
intSegment.CopyTo(intArray, 2);
Assert.Equal(new int[] { 0, 1, 1, 2, 3 }, intArray);
intArray = new int[] { 0, 1, 2, 3, 4 };
intSegment = new ArraySegment <int>(intArray, 1, 3);
intSegment.CopyTo(intArray, 0);
Assert.Equal(new int[] { 1, 2, 3, 3, 4 }, intArray);
}
public void TestCopyTo()
{
var array = new int[] { 1, 2, 3, 4, 5 };
var target = new ArraySegment <int>(array, 1, 3);
var result = new int[5];
// Copy all
Assert.That(target.CopyTo(0, result, 0, result.Length), Is.EqualTo(target.Count));
Assert.That(result, Is.EqualTo(new int[] { 2, 3, 4, 0, 0 }));
// Source offset
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(1, result, 0, result.Length), Is.EqualTo(target.Count - 1));
Assert.That(result, Is.EqualTo(new int[] { 3, 4, 0, 0, 0 }));
// Offset
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(0, result, 1, result.Length), Is.EqualTo(target.Count));
Assert.That(result, Is.EqualTo(new int[] { 0, 2, 3, 4, 0 }));
// Length
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(0, result, 0, result.Length - 1), Is.EqualTo(target.Count));
Assert.That(result, Is.EqualTo(new int[] { 2, 3, 4, 0, 0 }));
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(0, result, 0, target.Count - 1), Is.EqualTo(target.Count - 1));
Assert.That(result, Is.EqualTo(new int[] { 2, 3, 0, 0, 0 }));
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(0, result, 0, 0), Is.EqualTo(0));
Assert.That(result, Is.EqualTo(new int[] { 0, 0, 0, 0, 0 }));
Array.Clear(result, 0, result.Length);
Assert.That(target.CopyTo(0, result, 0, 1), Is.EqualTo(1));
Assert.That(result, Is.EqualTo(new int[] { 2, 0, 0, 0, 0 }));
}
public static void TestCopyTo()
{
{
string[] src;
IList<string> seg;
src = new string[] { "0", "1", "2", "3", "4" };
seg = new ArraySegment<string>(src, 1, 3);
seg.CopyTo(src, 2);
Assert.Equal(src, new string[] { "0", "1", "1", "2", "3" });
src = new string[] { "0", "1", "2", "3", "4" };
seg = new ArraySegment<string>(src, 1, 3);
seg.CopyTo(src, 0);
Assert.Equal(src, new string[] { "1", "2", "3", "3", "4" });
}
{
int[] src;
IList<int> seg;
src = new int[] { 0, 1, 2, 3, 4 };
seg = new ArraySegment<int>(src, 1, 3);
seg.CopyTo(src, 2);
Assert.Equal(src, new int[] { 0, 1, 1, 2, 3 });
src = new int[] { 0, 1, 2, 3, 4 };
seg = new ArraySegment<int>(src, 1, 3);
seg.CopyTo(src, 0);
Assert.Equal(src, new int[] { 1, 2, 3, 3, 4 });
}
}
public X509Certificate2 NewChainedCertificate(
DistinguishedName distinguishedName,
BasicConstraints basicConstraints,
ValidityPeriod validityPeriod,
SubjectAlternativeName subjectAlternativeName,
X509Certificate2 signingCertificate,
OidCollection enhancedKeyUsages,
X509KeyUsageFlags x509KeyUsageFlags)
{
if (signingCertificate == null)
{
throw new ArgumentNullException(nameof(signingCertificate));
}
if (!signingCertificate.HasPrivateKey)
{
throw new Exception("Signing cert must have private key");
}
using var ecdsa = ECDsa.Create("ECDsa");
ecdsa.KeySize = 256;
var request = new CertificateRequest(
_certificateUtility.CreateIssuerOrSubject(distinguishedName),
ecdsa,
HashAlgorithmName.SHA256);
_certificateUtility.AddBasicConstraints(request, basicConstraints);
_certificateUtility.AddExtendedKeyUsages(request, x509KeyUsageFlags);
// set the AuthorityKeyIdentifier. There is no built-in
// support, so it needs to be copied from the Subject Key
// Identifier of the signing certificate and massaged slightly.
// AuthorityKeyIdentifier is "KeyID=<subject key identifier>"
var issuerSubjectKey = signingCertificate.Extensions["Subject Key Identifier"].RawData;
var segment = new ArraySegment <byte>(issuerSubjectKey, 2, issuerSubjectKey.Length - 2);
var authorityKeyIdentifier = new byte[segment.Count + 4];
// "KeyID" bytes
authorityKeyIdentifier[0] = 0x30;
authorityKeyIdentifier[1] = 0x16;
authorityKeyIdentifier[2] = 0x80;
authorityKeyIdentifier[3] = 0x14;
segment.CopyTo(authorityKeyIdentifier, 4);
request.CertificateExtensions.Add(new X509Extension("2.5.29.35", authorityKeyIdentifier, false));
_certificateUtility.AddSubjectAlternativeName(request, subjectAlternativeName);
// Enhanced key usages
request.CertificateExtensions.Add(
new X509EnhancedKeyUsageExtension(enhancedKeyUsages, false));
// add this subject key identifier
request.CertificateExtensions.Add(
new X509SubjectKeyIdentifierExtension(request.PublicKey, false));
// certificate expiry: Valid from Yesterday to Now+365 days
// Unless the signing cert's validity is less. It's not possible
// to create a cert with longer validity than the signing cert.
var notbefore = validityPeriod.ValidFrom.AddDays(-1);
if (notbefore < signingCertificate.NotBefore)
{
notbefore = new DateTimeOffset(signingCertificate.NotBefore);
}
var notafter = validityPeriod.ValidTo;
if (notafter > signingCertificate.NotAfter)
{
notafter = new DateTimeOffset(signingCertificate.NotAfter);
}
// cert serial is the epoch/unix timestamp
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var unixTime = Convert.ToInt64((DateTime.UtcNow - epoch).TotalSeconds);
var serial = BitConverter.GetBytes(unixTime);
// create and return the generated and signed
using var cert = request.Create(
signingCertificate,
notbefore,
notafter,
serial);
return(cert.CopyWithPrivateKey(ecdsa));
}
/// <summary>
/// Creates a new certificate with the given subject name and signs it with the
/// certificate contained in the <paramref name="signingCertificate"/> parameter.
/// </summary>
/// <remarks>The generated certificate has the same attributes as the ones created
/// by the IoT Hub Device Provisioning samples</remarks>
/// <param name="subjectName">Subject name to give the new certificate</param>
/// <param name="signingCertificate">Certificate to sign the new certificate with</param>
/// <returns>A signed <see cref="X509Certificate2"/>.</returns>
internal static X509Certificate2 CreateAndSignCertificate(string subjectName, X509Certificate2 signingCertificate)
{
if (signingCertificate == null)
{
throw new ArgumentNullException(nameof(signingCertificate));
}
if (!signingCertificate.HasPrivateKey)
{
throw new Exception("Signing cert must have private key");
}
if (string.IsNullOrEmpty(subjectName))
{
throw new ArgumentException($"{nameof(subjectName)} must be a valid DNS name", nameof(subjectName));
}
if (UriHostNameType.Unknown == Uri.CheckHostName(subjectName))
{
throw new ArgumentException("Must be a valid DNS name", nameof(subjectName));
}
using (var ecdsa = ECDsa.Create("ECDsa"))
{
ecdsa.KeySize = 256;
var request = new CertificateRequest(
$"CN={subjectName}",
ecdsa,
HashAlgorithmName.SHA256);
// set basic certificate contraints
request.CertificateExtensions.Add(
new X509BasicConstraintsExtension(false, false, 0, true));
// key usage: Digital Signature and Key Encipherment
request.CertificateExtensions.Add(
new X509KeyUsageExtension(
X509KeyUsageFlags.DigitalSignature | X509KeyUsageFlags.KeyEncipherment,
true));
// set the AuthorityKeyIdentifier. There is no built-in
// support, so it needs to be copied from the Subject Key
// Identifier of the signing certificate and massaged slightly.
// AuthorityKeyIdentifier is "KeyID=<subject key identifier>"
var issuerSubjectKey = signingCertificate.Extensions["Subject Key Identifier"].RawData;
var segment = new ArraySegment <byte>(issuerSubjectKey, 2, issuerSubjectKey.Length - 2);
var authorityKeyIdentifer = new byte[segment.Count + 4];
// these bytes define the "KeyID" part of the AuthorityKeyIdentifer
authorityKeyIdentifer[0] = 0x30;
authorityKeyIdentifer[1] = 0x16;
authorityKeyIdentifer[2] = 0x80;
authorityKeyIdentifer[3] = 0x14;
segment.CopyTo(authorityKeyIdentifer, 4);
request.CertificateExtensions.Add(new X509Extension("2.5.29.35", authorityKeyIdentifer, false));
// DPS samples create certs with the device name as a SAN name
// in addition to the subject name
var sanBuilder = new SubjectAlternativeNameBuilder();
sanBuilder.AddDnsName(subjectName);
var sanExtension = sanBuilder.Build();
request.CertificateExtensions.Add(sanExtension);
// Enhanced key usages
request.CertificateExtensions.Add(
new X509EnhancedKeyUsageExtension(
new OidCollection {
new Oid("1.3.6.1.5.5.7.3.2"), // TLS Client auth
new Oid("1.3.6.1.5.5.7.3.1") // TLS Server auth
},
false));
// add this subject key identifier
request.CertificateExtensions.Add(
new X509SubjectKeyIdentifierExtension(request.PublicKey, false));
// certificate expiry: Valid from Yesterday to Now+365 days
// Unless the signing cert's validity is less. It's not possible
// to create a cert with longer validity than the signing cert.
var notbefore = DateTimeOffset.UtcNow.AddDays(-1);
if (notbefore < signingCertificate.NotBefore)
{
notbefore = new DateTimeOffset(signingCertificate.NotBefore);
}
var notafter = DateTimeOffset.UtcNow.AddDays(365);
if (notafter > signingCertificate.NotAfter)
{
notafter = new DateTimeOffset(signingCertificate.NotAfter);
}
// cert serial is the epoch/unix timestamp
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var unixTime = Convert.ToInt64((DateTime.UtcNow - epoch).TotalSeconds);
var serial = BitConverter.GetBytes(unixTime);
// create and return the generated and signed
using (var cert = request.Create(
signingCertificate,
notbefore,
notafter,
serial))
{
return(cert.CopyWithPrivateKey(ecdsa));
}
}
}
internal static X509Certificate2 CreateCaCertificate(string subjectName, string certificatePassword,
X509Certificate2 issuingCa)
{
using (var ecdsa = ECDsa.Create("ECDsa"))
{
ecdsa.KeySize = 256;
var request = new CertificateRequest(
$"CN={subjectName}",
ecdsa,
HashAlgorithmName.SHA256);
// set basic certificate contraints
request.CertificateExtensions.Add(
new X509BasicConstraintsExtension(true, true, 12, true));
// key usage: Digital Signature and Key Encipherment
request.CertificateExtensions.Add(
new X509KeyUsageExtension(
X509KeyUsageFlags.KeyCertSign,
true));
if (issuingCa != null)
{
// set the AuthorityKeyIdentifier. There is no built-in
// support, so it needs to be copied from the Subject Key
// Identifier of the signing certificate and massaged slightly.
// AuthorityKeyIdentifier is "KeyID=<subject key identifier>"
var issuerSubjectKey = issuingCa.Extensions["Subject Key Identifier"].RawData;
var segment = new ArraySegment <byte>(issuerSubjectKey, 2, issuerSubjectKey.Length - 2);
var authorityKeyIdentifier = new byte[segment.Count + 4];
// these bytes define the "KeyID" part of the AuthorityKeyIdentifer
authorityKeyIdentifier[0] = 0x30;
authorityKeyIdentifier[1] = 0x16;
authorityKeyIdentifier[2] = 0x80;
authorityKeyIdentifier[3] = 0x14;
segment.CopyTo(authorityKeyIdentifier, 4);
request.CertificateExtensions.Add(new X509Extension("2.5.29.35", authorityKeyIdentifier, false));
}
// DPS samples create certs with the device name as a SAN name
// in addition to the subject name
var sanBuilder = new SubjectAlternativeNameBuilder();
sanBuilder.AddDnsName(subjectName);
var sanExtension = sanBuilder.Build();
request.CertificateExtensions.Add(sanExtension);
// Enhanced key usages
request.CertificateExtensions.Add(
new X509EnhancedKeyUsageExtension(
new OidCollection {
new Oid("1.3.6.1.5.5.7.3.2"), // TLS Client auth
new Oid("1.3.6.1.5.5.7.3.1") // TLS Server auth
},
false));
// add this subject key identifier
request.CertificateExtensions.Add(
new X509SubjectKeyIdentifierExtension(request.PublicKey, false));
// certificate expiry: Valid from Yesterday to Now+365 days
// Unless the signing cert's validity is less. It's not possible
// to create a cert with longer validity than the signing cert.
var notbefore = DateTimeOffset.UtcNow.AddDays(-1);
if ((issuingCa != null) && (notbefore < issuingCa.NotBefore))
{
notbefore = new DateTimeOffset(issuingCa.NotBefore);
}
var notafter = DateTimeOffset.UtcNow.AddDays(365);
if ((issuingCa != null) && (notafter > issuingCa.NotAfter))
{
notafter = new DateTimeOffset(issuingCa.NotAfter);
}
// cert serial is the epoch/unix timestamp
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var unixTime = Convert.ToInt64((DateTime.UtcNow - epoch).TotalSeconds);
var serial = BitConverter.GetBytes(unixTime);
X509Certificate2 generatedCertificate = null;
if (issuingCa != null)
{
generatedCertificate = request.Create(issuingCa, notbefore, notafter, serial);
return(generatedCertificate.CopyWithPrivateKey(ecdsa));
}
else
{
generatedCertificate = request.CreateSelfSigned(
notbefore, notafter);
return(generatedCertificate);
}
}
}
public void TestCopyTo_EmptyArraySegment()
{
var array = new int[] { 1 };
var target = new ArraySegment<int>( array, 0, 0 );
var result = new int[ 5 ];
Assert.That( target.CopyTo( 0, result, 0, 1 ), Is.EqualTo( 0 ) );
}
public void TestCopyTo_SmallArray()
{
var array = new int[] { 1, 2, 3 };
var target = new ArraySegment<int>( array );
var result = new int[ 2 ];
Assert.That( target.CopyTo( 0, result, 0, result.Length ), Is.EqualTo( 2 ) );
Assert.That( result, Is.EqualTo( new int[] { 1, 2 } ) );
}
public void IList_CopyTo ()
{
var array = new long[] { 1, 2, 3, 4, 5, 6, -10 };
IList<long> s = new ArraySegment<long> (array, 2, 3);
long[] target = new long[s.Count];
s.CopyTo (target, 0);
Assert.AreEqual (3, target[0], "#1");
Assert.AreEqual (4, target[1], "#2");
}
internal static void CopyTo <T>(this T[] src, int srcOffset, IList <T> dst, int dstOffset, int count)
{
var srcArray = new ArraySegment <T>(src);
srcArray.CopyTo(srcOffset, dst, dstOffset, count);
}
unsafe UIntPtr NativeRead(SDL_RWops *io, byte *ptr, UIntPtr size, UIntPtr maxnum)
{
if (Implementation == null)
{
SetError($"{nameof(RWOpsFromInterface)} is missing an implementation to call");
return(UIntPtr.Zero);
}
try
{
for (ulong i = 0; i < (ulong)maxnum; ++i)
{
if (partial.Count < (int)size)
{
if (partial.Count > 0)
{
var arr = partial.Array;
System.Diagnostics.Debug.Assert(arr.Length > 0);
var l = partial.Count;
partial.CopyTo(arr);
partial = arr;
partial = partial.Slice(l);
}
else
{
partial = partial.Array;
}
Span <byte> buffer = partial;
try
{
int read = Implementation.Read(buffer);
if (read == 0)
{
return((UIntPtr)i - 1);
}
if (read < partial.Count)
{
partial = partial.Slice(0, read);
}
}
catch (Exception ex)
{
SetError(ex);
return((UIntPtr)i - 1);
}
if (partial.Count < (int)size)
{
return((UIntPtr)i - 1);
}
}
var target = new Span <byte>(ptr + i * (ulong)size, (int)size);
Span <byte> src = partial.Slice(0, (int)size);
partial = partial.Slice((int)size);
src.CopyTo(target);
}
return(maxnum);
}
catch (Exception ex)
{
SetError(ex);
return(UIntPtr.Zero);
}
}
public async ValueTask InitializeAsync(CancellationToken cancel)
{
await _underlying.InitializeAsync(cancel).ConfigureAwait(false);
try
{
// The server waits for the client's upgrade request, the client sends the upgrade request.
if (!_incoming)
{
// Compose the upgrade request.
var sb = new StringBuilder();
sb.Append("GET " + _resource + " HTTP/1.1\r\n");
sb.Append("Host: " + _host + "\r\n");
sb.Append("Upgrade: websocket\r\n");
sb.Append("Connection: Upgrade\r\n");
sb.Append("Sec-WebSocket-Protocol: " + IceProtocol + "\r\n");
sb.Append("Sec-WebSocket-Version: 13\r\n");
sb.Append("Sec-WebSocket-Key: ");
// The value for Sec-WebSocket-Key is a 16-byte random number, encoded with Base64.
byte[] key = new byte[16];
_rand.NextBytes(key);
_key = Convert.ToBase64String(key);
sb.Append(_key + "\r\n\r\n"); // EOM
byte[] data = _utf8.GetBytes(sb.ToString());
_sendBuffer.Add(data);
await _underlying.SendAsync(_sendBuffer, cancel).ConfigureAwait(false);
}
_sendBuffer.Clear();
// Try to read the client's upgrade request or the server's response.
var httpBuffer = new ArraySegment <byte>();
while (true)
{
ReadOnlyMemory <byte> buffer = await _underlying.ReceiveAsync(0, cancel).ConfigureAwait(false);
if (httpBuffer.Count + buffer.Length > _communicator.IncomingFrameSizeMax)
{
throw new InvalidDataException(
"WebSocket frame size is greater than the configured IncomingFrameSizeMax value");
}
ArraySegment <byte> tmpBuffer = new byte[httpBuffer.Count + buffer.Length];
if (httpBuffer.Count > 0)
{
httpBuffer.CopyTo(tmpBuffer);
}
buffer.CopyTo(tmpBuffer.Slice(httpBuffer.Count));
httpBuffer = tmpBuffer;
// Check if we have enough data for a complete frame.
int endPos = HttpParser.IsCompleteMessage(httpBuffer);
if (endPos != -1)
{
// Add back the un-consumed data to the buffer.
_underlying.Rewind(httpBuffer.Count - endPos);
httpBuffer = httpBuffer.Slice(0, endPos);
break; // Done
}
}
try
{
if (_parser.Parse(httpBuffer))
{
if (_incoming)
{
(bool addProtocol, string key) = ReadUpgradeRequest();
// Compose the response.
var sb = new StringBuilder();
sb.Append("HTTP/1.1 101 Switching Protocols\r\n");
sb.Append("Upgrade: websocket\r\n");
sb.Append("Connection: Upgrade\r\n");
if (addProtocol)
{
sb.Append($"Sec-WebSocket-Protocol: {IceProtocol}\r\n");
}
// The response includes:
//
// "A |Sec-WebSocket-Accept| header field. The value of this header field is constructed
// by concatenating /key/, defined above in step 4 in Section 4.2.2, with the string
// "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", taking the SHA-1 hash of this concatenated value
// to obtain a 20-byte value and base64-encoding (see Section 4 of [RFC4648]) this 20-byte
// hash.
sb.Append("Sec-WebSocket-Accept: ");
string input = key + WsUUID;
#pragma warning disable CA5350 // Do Not Use Weak Cryptographic Algorithms
using var sha1 = SHA1.Create();
byte[] hash = sha1.ComputeHash(_utf8.GetBytes(input));
#pragma warning restore CA5350 // Do Not Use Weak Cryptographic Algorithms
sb.Append(Convert.ToBase64String(hash) + "\r\n" + "\r\n"); // EOM
Debug.Assert(_sendBuffer.Count == 0);
byte[] data = _utf8.GetBytes(sb.ToString());
_sendBuffer.Add(data);
await _underlying.SendAsync(_sendBuffer, cancel).ConfigureAwait(false);
_sendBuffer.Clear();
}
else
{
ReadUpgradeResponse();
}
}
else
{
throw new InvalidDataException("incomplete WebSocket request frame");
}
}
catch (WebSocketException ex)
{
throw new InvalidDataException(ex.Message, ex);
}
}
catch (Exception ex)
{
if (_communicator.TraceLevels.Transport >= 2)
{
_communicator.Logger.Trace(TraceLevels.TransportCategory,
$"{_transportName} connection HTTP upgrade request failed\n{this}\n{ex}");
}
throw;
}
if (_communicator.TraceLevels.Transport >= 1)
{
if (_incoming)
{
_communicator.Logger.Trace(TraceLevels.TransportCategory,
$"accepted {_transportName} connection HTTP upgrade request\n{this}");
}
else
{
_communicator.Logger.Trace(TraceLevels.TransportCategory,
$"{_transportName} connection HTTP upgrade request accepted\n{this}");
}
}
}
internal bool TryLoopbackToServer(ArraySegment <byte> packet)
{
if (IsServer)
{
var p = new PureP2PPeer(true);
_loopbackToServer.Add(new KeyValuePair <PureP2PPeer, ArraySegment <byte> >(p, packet.CopyTo(_loopbackBuffers.Get())));
return(true);
}
return(false);
}
public static void TestIList_CopyTo_Invalid()
{
IList<int> iList = new ArraySegment<int>();
Assert.Throws<InvalidOperationException>(() => iList.CopyTo(new int[7], 0)); // Array is null
var intArray = new int[] { 7, 8, 9, 10, 11, 12, 13 };
iList = new ArraySegment<int>(intArray, 2, 3);
Assert.Throws<ArgumentNullException>("dest", () => iList.CopyTo(null, 0)); // Destination array is null
Assert.Throws<ArgumentOutOfRangeException>("dstIndex", () => iList.CopyTo(new int[7], -1)); // Index < 0
Assert.Throws<ArgumentException>("", () => iList.CopyTo(new int[7], 8)); // Index > destinationArray.Length
}
private void ROMix(ArraySegment<byte> B, byte[] X, byte[] Y, byte[] V)
{
B.CopyTo(X, 0);
for (int i = 0; i < Cost; ++i)
{
Array.Copy(X, 0, V, i * (128 * BlockSize), 128 * BlockSize);
BlockMix(X, Y);
}
for (int i = 0; i < Cost; ++i)
{
ulong j = BitConverter.ToUInt64(X, (2 * BlockSize - 1) * 64);
j %= (ulong)Cost;
for (int k = 0; k < 128 * BlockSize; ++k)
{
X[k] ^= V[j * (128 * (ulong)BlockSize) + (ulong)k];
}
BlockMix(X, Y);
}
ArraySegment<byte>.Copy(X, B, 128 * BlockSize);
}
public void TestCopyTo_EmptySourceArray()
{
var array = new int[ 0 ];
var target = new ArraySegment<int>( array );
var result = new int[ 5 ];
Assert.That( target.CopyTo( 0, result, 0, 1 ), Is.EqualTo( 0 ) );
}
public static void TestIList_CopyTo()
{
var stringArray = new string[] { "0", "1", "2", "3", "4" };
IList<string> stringSegment = new ArraySegment<string>(stringArray, 1, 3);
stringSegment.CopyTo(stringArray, 2);
Assert.Equal(new string[] { "0", "1", "1", "2", "3" }, stringArray);
stringArray = new string[] { "0", "1", "2", "3", "4" };
stringSegment = new ArraySegment<string>(stringArray, 1, 3);
stringSegment.CopyTo(stringArray, 0);
Assert.Equal(new string[] { "1", "2", "3", "3", "4" }, stringArray);
var intArray = new int[] { 0, 1, 2, 3, 4 };
IList<int> intSegment = new ArraySegment<int>(intArray, 1, 3);
intSegment.CopyTo(intArray, 2);
Assert.Equal(new int[] { 0, 1, 1, 2, 3 }, intArray);
intArray = new int[] { 0, 1, 2, 3, 4 };
intSegment = new ArraySegment<int>(intArray, 1, 3);
intSegment.CopyTo(intArray, 0);
Assert.Equal(new int[] { 1, 2, 3, 3, 4 }, intArray);
}