diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6fa687b --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/dotnet-v3.1.101-SDK.tar.gz +/dotnet-v3.1.102-SDK.tar.gz +/dotnet-v3.1.103.2-SDK.tar.gz diff --git a/README.md b/README.md index 9a67806..df95803 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,133 @@ # dotnet5.0 -The dotnet5.0 package +This is the .NET 5.0 package for Fedora. + +This package is maintained by the Fedora DotNet SIG (Special Interest +Group). You can find out more about the DotNet SIG at: + +- https://fedoraproject.org/wiki/SIGs/DotNet +- https://fedoraproject.org/wiki/DotNet +- https://lists.fedoraproject.org/archives/list/dotnet-sig@lists.fedoraproject.org/ + +Please report any issues [using +bugzilla](https://bugzilla.redhat.com/enter_bug.cgi?product=Fedora&component=dotnet5.0). + +# Specification + +This package follows [package naming and contents suggested by +upstream](https://docs.microsoft.com/en-us/dotnet/core/build/distribution-packaging), +with one exception. It installs dotnet to `/usr/lib64/dotnet` (aka +`%{_libdir}`). + +# Contributing + +## General Changes + +1. Fork the repo. + +2. Checkout the forked repository. + + - `git clone ssh://$USER@pkgs.fedoraproject.org/forks/$USER/rpms/dotnet5.0.git` + - `cd dotnet5.0` + +3. Make your changes. Don't forget to add a changelog. + +4. Do local builds. + + - `fedpkg local` + +5. Fix any errors that come up and rebuild until it works locally. + +6. Do builds in koji. + + - `fedpkg scratch-build --srpm` + +8. Commit the changes to the git repo. + + - `git add` any new patches + - `git remove` any now-unnecessary patches + - `git commit -a` + - `git push` + +9. Create a pull request with your changes. + +10. Once the tests in the pull-request pass, and reviewers are happy, do a real + build. + + - `fedpkg build` + +11. For non-rawhide releases, file updates using bodhi to ship the just-built + package out to users. + + - https://bodhi.fedoraproject.org/updates/new + + OR + + - `fedpkg update` + +## Updating to an new upstream release + +1. Fork the repo. + +2. Checkout the forked repository. + + - `git clone ssh://$USER@pkgs.fedoraproject.org/forks/$USER/rpms/dotnet5.0.git` + - `cd dotnet5.0` + +3. Build the new upstream source tarball. Update the versions in the + spec file. Add a changelog. This is generally automated by the + following. + + - `./update-release ` + + If this fails because of compiler errors, you might have to figure + out a fix, then add the patch in `build-dotnet-tarball` script + rather than the spec file. + +4. Do local builds. + + - `fedpkg local` + +5. Fix any errors that come up and rebuild until it works locally. Any + patches that are needed at this point should be added to the spec file. + +6. Do builds in koji. + + - `fedpkg scratch-build --srpm` + +7. Upload the source archive to the Fedora look-aside cache. + + - `fedpkg new-sources path-to-generated-dotnet-source-tarball.tar.gz` + +8. Commit the changes to the git repo. + + - `git add` any new patches + - `git remove` any now-unnecessary patches + - `git commit -a` + - `git push` + +9. Create a pull request with your changes. + +10. Once the tests in the pull-request pass, and reviewers are happy, do a real + build. + + - `fedpkg build` + +11. For non-rawhide releases, file updates using bodhi to ship the just-built + package out to users. + + - https://bodhi.fedoraproject.org/updates/new + + OR + + - `fedpkg update` + +# Testing + +This package uses CI tests as defined in `tests/test.yml`. Creating a +pull-request or running a build will fire off tests and flag any issues. We have +enabled gating (via `gating.yaml`) on the tests. That prevents a build +that fails any test from being released until the failures are waived. + +The tests themselves are contained in this external repository: +https://github.com/redhat-developer/dotnet-regular-tests/ diff --git a/SHAHashProvider.Browser.cs b/SHAHashProvider.Browser.cs new file mode 100644 index 0000000..4515b8a --- /dev/null +++ b/SHAHashProvider.Browser.cs @@ -0,0 +1,1184 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.IO; +using System.Diagnostics; +using System.Numerics; +using System.Security.Cryptography; + +namespace Internal.Cryptography +{ + internal sealed class SHAHashProvider : HashProvider + { + private int hashSizeInBytes; + private SHAManagedImplementationBase impl; + private MemoryStream buffer; + + public SHAHashProvider(string hashAlgorithmId) + { + switch (hashAlgorithmId) + { + case HashAlgorithmNames.SHA1: + impl = new SHA1ManagedImplementation(); + hashSizeInBytes = 20; + break; + case HashAlgorithmNames.SHA256: + impl = new SHA256ManagedImplementation(); + hashSizeInBytes = 32; + break; + case HashAlgorithmNames.SHA384: + impl = new SHA384ManagedImplementation(); + hashSizeInBytes = 48; + break; + case HashAlgorithmNames.SHA512: + impl = new SHA512ManagedImplementation(); + hashSizeInBytes = 64; + break; + default: + throw new CryptographicException(SR.Format(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithmId)); + } + } + + public override void AppendHashData(ReadOnlySpan data) + { + if (buffer == null) + { + buffer = new MemoryStream(1000); + } + + buffer.Write(data); + } + + public override int FinalizeHashAndReset(Span destination) + { + GetCurrentHash(destination); + buffer = null; + + return hashSizeInBytes; + } + + public override int GetCurrentHash(Span destination) + { + Debug.Assert(destination.Length >= hashSizeInBytes); + + impl.Initialize(); + if (buffer != null) + { + impl.HashCore(buffer.GetBuffer(), 0, (int)buffer.Length); + } + impl.HashFinal().CopyTo(destination); + + return hashSizeInBytes; + } + + public override int HashSizeInBytes => hashSizeInBytes; + + public override void Dispose(bool disposing) + { + } + + private abstract class SHAManagedImplementationBase + { + public abstract void Initialize(); + public abstract void HashCore(byte[] partIn, int ibStart, int cbSize); + public abstract byte[] HashFinal(); + } + + // Ported from src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs. + // n.b. It's ok to use a "non-secret purposes" hashing implementation here, as this is only + // used in wasm scenarios, and as of the current release we don't make any security guarantees + // about our crypto primitives in wasm environments. + private class SHA1ManagedImplementation : SHAManagedImplementationBase + { + private Sha1ForNonSecretPurposes _state; // mutable struct - don't make readonly + + public override void Initialize() + { + _state = default; + _state.Start(); + } + + public override void HashCore(byte[] partIn, int ibStart, int cbSize) + { + _state.Append(partIn.AsSpan(ibStart, cbSize)); + } + + public override byte[] HashFinal() + { + byte[] output = new byte[20]; + _state.Finish(output); + return output; + } + + /// + /// Implements the SHA1 hashing algorithm. Note that this + /// implementation is for hashing public information. Do not + /// use this code to hash private data, as this implementation does + /// not take any steps to avoid information disclosure. + /// + private struct Sha1ForNonSecretPurposes + { + private long length; // Total message length in bits + private uint[] w; // Workspace + private int pos; // Length of current chunk in bytes + + /// + /// Call Start() to initialize the hash object. + /// + public void Start() + { + this.w ??= new uint[85]; + + this.length = 0; + this.pos = 0; + this.w[80] = 0x67452301; + this.w[81] = 0xEFCDAB89; + this.w[82] = 0x98BADCFE; + this.w[83] = 0x10325476; + this.w[84] = 0xC3D2E1F0; + } + + /// + /// Adds an input byte to the hash. + /// + /// Data to include in the hash. + public void Append(byte input) + { + this.w[this.pos / 4] = (this.w[this.pos / 4] << 8) | input; + if (64 == ++this.pos) + { + this.Drain(); + } + } + + /// + /// Adds input bytes to the hash. + /// + /// + /// Data to include in the hash. Must not be null. + /// + public void Append(ReadOnlySpan input) + { + foreach (byte b in input) + { + this.Append(b); + } + } + + /// + /// Retrieves the hash value. + /// Note that after calling this function, the hash object should + /// be considered uninitialized. Subsequent calls to Append or + /// Finish will produce useless results. Call Start() to + /// reinitialize. + /// + /// + /// Buffer to receive the hash value. Must not be null. + /// Up to 20 bytes of hash will be written to the output buffer. + /// If the buffer is smaller than 20 bytes, the remaining hash + /// bytes will be lost. If the buffer is larger than 20 bytes, the + /// rest of the buffer is left unmodified. + /// + public void Finish(byte[] output) + { + long l = this.length + 8 * this.pos; + this.Append(0x80); + while (this.pos != 56) + { + this.Append(0x00); + } + + unchecked + { + this.Append((byte)(l >> 56)); + this.Append((byte)(l >> 48)); + this.Append((byte)(l >> 40)); + this.Append((byte)(l >> 32)); + this.Append((byte)(l >> 24)); + this.Append((byte)(l >> 16)); + this.Append((byte)(l >> 8)); + this.Append((byte)l); + + int end = output.Length < 20 ? output.Length : 20; + for (int i = 0; i != end; i++) + { + uint temp = this.w[80 + i / 4]; + output[i] = (byte)(temp >> 24); + this.w[80 + i / 4] = temp << 8; + } + } + } + + /// + /// Called when this.pos reaches 64. + /// + private void Drain() + { + for (int i = 16; i != 80; i++) + { + this.w[i] = BitOperations.RotateLeft(this.w[i - 3] ^ this.w[i - 8] ^ this.w[i - 14] ^ this.w[i - 16], 1); + } + + unchecked + { + uint a = this.w[80]; + uint b = this.w[81]; + uint c = this.w[82]; + uint d = this.w[83]; + uint e = this.w[84]; + + for (int i = 0; i != 20; i++) + { + const uint k = 0x5A827999; + uint f = (b & c) | ((~b) & d); + uint temp = BitOperations.RotateLeft(a, 5) + f + e + k + this.w[i]; e = d; d = c; c = BitOperations.RotateLeft(b, 30); b = a; a = temp; + } + + for (int i = 20; i != 40; i++) + { + uint f = b ^ c ^ d; + const uint k = 0x6ED9EBA1; + uint temp = BitOperations.RotateLeft(a, 5) + f + e + k + this.w[i]; e = d; d = c; c = BitOperations.RotateLeft(b, 30); b = a; a = temp; + } + + for (int i = 40; i != 60; i++) + { + uint f = (b & c) | (b & d) | (c & d); + const uint k = 0x8F1BBCDC; + uint temp = BitOperations.RotateLeft(a, 5) + f + e + k + this.w[i]; e = d; d = c; c = BitOperations.RotateLeft(b, 30); b = a; a = temp; + } + + for (int i = 60; i != 80; i++) + { + uint f = b ^ c ^ d; + const uint k = 0xCA62C1D6; + uint temp = BitOperations.RotateLeft(a, 5) + f + e + k + this.w[i]; e = d; d = c; c = BitOperations.RotateLeft(b, 30); b = a; a = temp; + } + + this.w[80] += a; + this.w[81] += b; + this.w[82] += c; + this.w[83] += d; + this.w[84] += e; + } + + this.length += 512; // 64 bytes == 512 bits + this.pos = 0; + } + } + } + + // ported from https://github.com/microsoft/referencesource/blob/a48449cb48a9a693903668a71449ac719b76867c/mscorlib/system/security/cryptography/sha256managed.cs + private class SHA256ManagedImplementation : SHAManagedImplementationBase + { + private byte[] _buffer; + private long _count; // Number of bytes in the hashed message + private uint[] _stateSHA256; + private uint[] _W; + + public SHA256ManagedImplementation() + { + _stateSHA256 = new uint[8]; + _buffer = new byte[64]; + _W = new uint[64]; + + InitializeState(); + } + + public override void Initialize() + { + InitializeState(); + + // Zeroize potentially sensitive information. + Array.Clear(_buffer, 0, _buffer.Length); + Array.Clear(_W, 0, _W.Length); + } + + private void InitializeState() + { + _count = 0; + + _stateSHA256[0] = 0x6a09e667; + _stateSHA256[1] = 0xbb67ae85; + _stateSHA256[2] = 0x3c6ef372; + _stateSHA256[3] = 0xa54ff53a; + _stateSHA256[4] = 0x510e527f; + _stateSHA256[5] = 0x9b05688c; + _stateSHA256[6] = 0x1f83d9ab; + _stateSHA256[7] = 0x5be0cd19; + } + + /* SHA256 block update operation. Continues an SHA message-digest + operation, processing another message block, and updating the + context. + */ + public override unsafe void HashCore(byte[] partIn, int ibStart, int cbSize) + { + int bufferLen; + int partInLen = cbSize; + int partInBase = ibStart; + + /* Compute length of buffer */ + bufferLen = (int)(_count & 0x3f); + + /* Update number of bytes */ + _count += partInLen; + + fixed (uint* stateSHA256 = _stateSHA256) + { + fixed (byte* buffer = _buffer) + { + fixed (uint* expandedBuffer = _W) + { + if ((bufferLen > 0) && (bufferLen + partInLen >= 64)) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, 64 - bufferLen); + partInBase += (64 - bufferLen); + partInLen -= (64 - bufferLen); + SHATransform(expandedBuffer, stateSHA256, buffer); + bufferLen = 0; + } + + /* Copy input to temporary buffer and hash */ + while (partInLen >= 64) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, 0, 64); + partInBase += 64; + partInLen -= 64; + SHATransform(expandedBuffer, stateSHA256, buffer); + } + + if (partInLen > 0) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, partInLen); + } + } + } + } + } + + /* SHA256 finalization. Ends an SHA256 message-digest operation, writing + the message digest. + */ + public override byte[] HashFinal() + { + byte[] pad; + int padLen; + long bitCount; + byte[] hash = new byte[32]; // HashSizeValue = 256 + + /* Compute padding: 80 00 00 ... 00 00 + */ + + padLen = 64 - (int)(_count & 0x3f); + if (padLen <= 8) + padLen += 64; + + pad = new byte[padLen]; + pad[0] = 0x80; + + // Convert count to bit count + bitCount = _count * 8; + + pad[padLen - 8] = (byte)((bitCount >> 56) & 0xff); + pad[padLen - 7] = (byte)((bitCount >> 48) & 0xff); + pad[padLen - 6] = (byte)((bitCount >> 40) & 0xff); + pad[padLen - 5] = (byte)((bitCount >> 32) & 0xff); + pad[padLen - 4] = (byte)((bitCount >> 24) & 0xff); + pad[padLen - 3] = (byte)((bitCount >> 16) & 0xff); + pad[padLen - 2] = (byte)((bitCount >> 8) & 0xff); + pad[padLen - 1] = (byte)((bitCount >> 0) & 0xff); + + /* Digest padding */ + HashCore(pad, 0, pad.Length); + + /* Store digest */ + SHAUtils.DWORDToBigEndian(hash, _stateSHA256, 8); + + return hash; + } + + private static readonly uint[] _K = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 + }; + + private static unsafe void SHATransform(uint* expandedBuffer, uint* state, byte* block) + { + uint a, b, c, d, e, f, h, g; + uint aa, bb, cc, dd, ee, ff, hh, gg; + uint T1; + + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + f = state[5]; + g = state[6]; + h = state[7]; + + // fill in the first 16 bytes of W. + SHAUtils.DWORDFromBigEndian(expandedBuffer, 16, block); + SHA256Expand(expandedBuffer); + + /* Apply the SHA256 compression function */ + // We are trying to be smart here and avoid as many copies as we can + // The perf gain with this method over the straightforward modify and shift + // forward is >= 20%, so it's worth the pain + for (int j = 0; j < 64;) + { + T1 = h + Sigma_1(e) + Ch(e, f, g) + _K[j] + expandedBuffer[j]; + ee = d + T1; + aa = T1 + Sigma_0(a) + Maj(a, b, c); + j++; + + T1 = g + Sigma_1(ee) + Ch(ee, e, f) + _K[j] + expandedBuffer[j]; + ff = c + T1; + bb = T1 + Sigma_0(aa) + Maj(aa, a, b); + j++; + + T1 = f + Sigma_1(ff) + Ch(ff, ee, e) + _K[j] + expandedBuffer[j]; + gg = b + T1; + cc = T1 + Sigma_0(bb) + Maj(bb, aa, a); + j++; + + T1 = e + Sigma_1(gg) + Ch(gg, ff, ee) + _K[j] + expandedBuffer[j]; + hh = a + T1; + dd = T1 + Sigma_0(cc) + Maj(cc, bb, aa); + j++; + + T1 = ee + Sigma_1(hh) + Ch(hh, gg, ff) + _K[j] + expandedBuffer[j]; + h = aa + T1; + d = T1 + Sigma_0(dd) + Maj(dd, cc, bb); + j++; + + T1 = ff + Sigma_1(h) + Ch(h, hh, gg) + _K[j] + expandedBuffer[j]; + g = bb + T1; + c = T1 + Sigma_0(d) + Maj(d, dd, cc); + j++; + + T1 = gg + Sigma_1(g) + Ch(g, h, hh) + _K[j] + expandedBuffer[j]; + f = cc + T1; + b = T1 + Sigma_0(c) + Maj(c, d, dd); + j++; + + T1 = hh + Sigma_1(f) + Ch(f, g, h) + _K[j] + expandedBuffer[j]; + e = dd + T1; + a = T1 + Sigma_0(b) + Maj(b, c, d); + j++; + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; + } + + private static uint RotateRight(uint x, int n) + { + return (((x) >> (n)) | ((x) << (32 - (n)))); + } + + private static uint Ch(uint x, uint y, uint z) + { + return ((x & y) ^ ((x ^ 0xffffffff) & z)); + } + + private static uint Maj(uint x, uint y, uint z) + { + return ((x & y) ^ (x & z) ^ (y & z)); + } + + private static uint sigma_0(uint x) + { + return (RotateRight(x, 7) ^ RotateRight(x, 18) ^ (x >> 3)); + } + + private static uint sigma_1(uint x) + { + return (RotateRight(x, 17) ^ RotateRight(x, 19) ^ (x >> 10)); + } + + private static uint Sigma_0(uint x) + { + return (RotateRight(x, 2) ^ RotateRight(x, 13) ^ RotateRight(x, 22)); + } + + private static uint Sigma_1(uint x) + { + return (RotateRight(x, 6) ^ RotateRight(x, 11) ^ RotateRight(x, 25)); + } + + /* This function creates W_16,...,W_63 according to the formula + W_j <- sigma_1(W_{j-2}) + W_{j-7} + sigma_0(W_{j-15}) + W_{j-16}; + */ + private static unsafe void SHA256Expand(uint* x) + { + for (int i = 16; i < 64; i++) + { + x[i] = sigma_1(x[i - 2]) + x[i - 7] + sigma_0(x[i - 15]) + x[i - 16]; + } + } + } + + // ported from https://github.com/microsoft/referencesource/blob/a48449cb48a9a693903668a71449ac719b76867c/mscorlib/system/security/cryptography/sha384managed.cs + private class SHA384ManagedImplementation : SHAManagedImplementationBase + { + private byte[] _buffer; + private ulong _count; // Number of bytes in the hashed message + private ulong[] _stateSHA384; + private ulong[] _W; + + public SHA384ManagedImplementation() + { + _stateSHA384 = new ulong[8]; + _buffer = new byte[128]; + _W = new ulong[80]; + + InitializeState(); + } + + public override void Initialize() + { + InitializeState(); + + // Zeroize potentially sensitive information. + Array.Clear(_buffer, 0, _buffer.Length); + Array.Clear(_W, 0, _W.Length); + } + + private void InitializeState() + { + _count = 0; + + _stateSHA384[0] = 0xcbbb9d5dc1059ed8; + _stateSHA384[1] = 0x629a292a367cd507; + _stateSHA384[2] = 0x9159015a3070dd17; + _stateSHA384[3] = 0x152fecd8f70e5939; + _stateSHA384[4] = 0x67332667ffc00b31; + _stateSHA384[5] = 0x8eb44a8768581511; + _stateSHA384[6] = 0xdb0c2e0d64f98fa7; + _stateSHA384[7] = 0x47b5481dbefa4fa4; + } + + /* SHA384 block update operation. Continues an SHA message-digest + operation, processing another message block, and updating the + context. + */ + public override unsafe void HashCore(byte[] partIn, int ibStart, int cbSize) + { + int bufferLen; + int partInLen = cbSize; + int partInBase = ibStart; + + /* Compute length of buffer */ + bufferLen = (int)(_count & 0x7f); + + /* Update number of bytes */ + _count += (ulong)partInLen; + + fixed (ulong* stateSHA384 = _stateSHA384) + { + fixed (byte* buffer = _buffer) + { + fixed (ulong* expandedBuffer = _W) + { + if ((bufferLen > 0) && (bufferLen + partInLen >= 128)) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, 128 - bufferLen); + partInBase += (128 - bufferLen); + partInLen -= (128 - bufferLen); + SHATransform(expandedBuffer, stateSHA384, buffer); + bufferLen = 0; + } + + /* Copy input to temporary buffer and hash */ + while (partInLen >= 128) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, 0, 128); + partInBase += 128; + partInLen -= 128; + SHATransform(expandedBuffer, stateSHA384, buffer); + } + + if (partInLen > 0) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, partInLen); + } + } + } + } + } + + /* SHA384 finalization. Ends an SHA384 message-digest operation, writing + the message digest. + */ + public override byte[] HashFinal() + { + byte[] pad; + int padLen; + ulong bitCount; + byte[] hash = new byte[48]; // HashSizeValue = 384 + + /* Compute padding: 80 00 00 ... 00 00 + */ + + padLen = 128 - (int)(_count & 0x7f); + if (padLen <= 16) + padLen += 128; + + pad = new byte[padLen]; + pad[0] = 0x80; + + // Convert count to bit count + bitCount = _count * 8; + + // bitCount is at most 8 * 128 = 1024. Its representation as a 128-bit number has all bits set to zero + // except eventually the 11 lower bits + + //pad[padLen-16] = (byte) ((bitCount >> 120) & 0xff); + //pad[padLen-15] = (byte) ((bitCount >> 112) & 0xff); + //pad[padLen-14] = (byte) ((bitCount >> 104) & 0xff); + //pad[padLen-13] = (byte) ((bitCount >> 96) & 0xff); + //pad[padLen-12] = (byte) ((bitCount >> 88) & 0xff); + //pad[padLen-11] = (byte) ((bitCount >> 80) & 0xff); + //pad[padLen-10] = (byte) ((bitCount >> 72) & 0xff); + //pad[padLen-9] = (byte) ((bitCount >> 64) & 0xff); + pad[padLen - 8] = (byte)((bitCount >> 56) & 0xff); + pad[padLen - 7] = (byte)((bitCount >> 48) & 0xff); + pad[padLen - 6] = (byte)((bitCount >> 40) & 0xff); + pad[padLen - 5] = (byte)((bitCount >> 32) & 0xff); + pad[padLen - 4] = (byte)((bitCount >> 24) & 0xff); + pad[padLen - 3] = (byte)((bitCount >> 16) & 0xff); + pad[padLen - 2] = (byte)((bitCount >> 8) & 0xff); + pad[padLen - 1] = (byte)((bitCount >> 0) & 0xff); + + /* Digest padding */ + HashCore(pad, 0, pad.Length); + + /* Store digest */ + SHAUtils.QuadWordToBigEndian(hash, _stateSHA384, 6); + + return hash; + } + + private static readonly ulong[] _K = { + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, + 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, + 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, + 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, + 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, + }; + + private static unsafe void SHATransform(ulong* expandedBuffer, ulong* state, byte* block) + { + ulong a, b, c, d, e, f, g, h; + ulong aa, bb, cc, dd, ee, ff, hh, gg; + ulong T1; + + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + f = state[5]; + g = state[6]; + h = state[7]; + + // fill in the first 16 blocks of W. + SHAUtils.QuadWordFromBigEndian(expandedBuffer, 16, block); + SHA384Expand(expandedBuffer); + + /* Apply the SHA384 compression function */ + // We are trying to be smart here and avoid as many copies as we can + // The perf gain with this method over the straightforward modify and shift + // forward is >= 20%, so it's worth the pain + for (int j = 0; j < 80;) + { + T1 = h + Sigma_1(e) + Ch(e, f, g) + _K[j] + expandedBuffer[j]; + ee = d + T1; + aa = T1 + Sigma_0(a) + Maj(a, b, c); + j++; + + T1 = g + Sigma_1(ee) + Ch(ee, e, f) + _K[j] + expandedBuffer[j]; + ff = c + T1; + bb = T1 + Sigma_0(aa) + Maj(aa, a, b); + j++; + + T1 = f + Sigma_1(ff) + Ch(ff, ee, e) + _K[j] + expandedBuffer[j]; + gg = b + T1; + cc = T1 + Sigma_0(bb) + Maj(bb, aa, a); + j++; + + T1 = e + Sigma_1(gg) + Ch(gg, ff, ee) + _K[j] + expandedBuffer[j]; + hh = a + T1; + dd = T1 + Sigma_0(cc) + Maj(cc, bb, aa); + j++; + + T1 = ee + Sigma_1(hh) + Ch(hh, gg, ff) + _K[j] + expandedBuffer[j]; + h = aa + T1; + d = T1 + Sigma_0(dd) + Maj(dd, cc, bb); + j++; + + T1 = ff + Sigma_1(h) + Ch(h, hh, gg) + _K[j] + expandedBuffer[j]; + g = bb + T1; + c = T1 + Sigma_0(d) + Maj(d, dd, cc); + j++; + + T1 = gg + Sigma_1(g) + Ch(g, h, hh) + _K[j] + expandedBuffer[j]; + f = cc + T1; + b = T1 + Sigma_0(c) + Maj(c, d, dd); + j++; + + T1 = hh + Sigma_1(f) + Ch(f, g, h) + _K[j] + expandedBuffer[j]; + e = dd + T1; + a = T1 + Sigma_0(b) + Maj(b, c, d); + j++; + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; + } + + private static ulong RotateRight(ulong x, int n) + { + return (((x) >> (n)) | ((x) << (64 - (n)))); + } + + private static ulong Ch(ulong x, ulong y, ulong z) + { + return ((x & y) ^ ((x ^ 0xffffffffffffffff) & z)); + } + + private static ulong Maj(ulong x, ulong y, ulong z) + { + return ((x & y) ^ (x & z) ^ (y & z)); + } + + private static ulong Sigma_0(ulong x) + { + return (RotateRight(x, 28) ^ RotateRight(x, 34) ^ RotateRight(x, 39)); + } + + private static ulong Sigma_1(ulong x) + { + return (RotateRight(x, 14) ^ RotateRight(x, 18) ^ RotateRight(x, 41)); + } + + private static ulong sigma_0(ulong x) + { + return (RotateRight(x, 1) ^ RotateRight(x, 8) ^ (x >> 7)); + } + + private static ulong sigma_1(ulong x) + { + return (RotateRight(x, 19) ^ RotateRight(x, 61) ^ (x >> 6)); + } + + /* This function creates W_16,...,W_79 according to the formula + W_j <- sigma_1(W_{j-2}) + W_{j-7} + sigma_0(W_{j-15}) + W_{j-16}; + */ + private static unsafe void SHA384Expand(ulong* x) + { + for (int i = 16; i < 80; i++) + { + x[i] = sigma_1(x[i - 2]) + x[i - 7] + sigma_0(x[i - 15]) + x[i - 16]; + } + } + } + + // ported from https://github.com/microsoft/referencesource/blob/a48449cb48a9a693903668a71449ac719b76867c/mscorlib/system/security/cryptography/sha512managed.cs + private class SHA512ManagedImplementation : SHAManagedImplementationBase + { + private byte[] _buffer; + private ulong _count; // Number of bytes in the hashed message + private ulong[] _stateSHA512; + private ulong[] _W; + + public SHA512ManagedImplementation() + { + _stateSHA512 = new ulong[8]; + _buffer = new byte[128]; + _W = new ulong[80]; + + InitializeState(); + } + + public override void Initialize() + { + InitializeState(); + + // Zeroize potentially sensitive information. + Array.Clear(_buffer, 0, _buffer.Length); + Array.Clear(_W, 0, _W.Length); + } + + private void InitializeState() + { + _count = 0; + + _stateSHA512[0] = 0x6a09e667f3bcc908; + _stateSHA512[1] = 0xbb67ae8584caa73b; + _stateSHA512[2] = 0x3c6ef372fe94f82b; + _stateSHA512[3] = 0xa54ff53a5f1d36f1; + _stateSHA512[4] = 0x510e527fade682d1; + _stateSHA512[5] = 0x9b05688c2b3e6c1f; + _stateSHA512[6] = 0x1f83d9abfb41bd6b; + _stateSHA512[7] = 0x5be0cd19137e2179; + } + + /* SHA512 block update operation. Continues an SHA message-digest + operation, processing another message block, and updating the + context. + */ + public override unsafe void HashCore(byte[] partIn, int ibStart, int cbSize) + { + int bufferLen; + int partInLen = cbSize; + int partInBase = ibStart; + + /* Compute length of buffer */ + bufferLen = (int)(_count & 0x7f); + + /* Update number of bytes */ + _count += (ulong)partInLen; + + fixed (ulong* stateSHA512 = _stateSHA512) + { + fixed (byte* buffer = _buffer) + { + fixed (ulong* expandedBuffer = _W) + { + if ((bufferLen > 0) && (bufferLen + partInLen >= 128)) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, 128 - bufferLen); + partInBase += (128 - bufferLen); + partInLen -= (128 - bufferLen); + SHATransform(expandedBuffer, stateSHA512, buffer); + bufferLen = 0; + } + + /* Copy input to temporary buffer and hash */ + while (partInLen >= 128) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, 0, 128); + partInBase += 128; + partInLen -= 128; + SHATransform(expandedBuffer, stateSHA512, buffer); + } + + if (partInLen > 0) + { + Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, partInLen); + } + } + } + } + } + + /* SHA512 finalization. Ends an SHA512 message-digest operation, writing + the message digest. + */ + public override byte[] HashFinal() + { + byte[] pad; + int padLen; + ulong bitCount; + byte[] hash = new byte[64]; // HashSizeValue = 512 + + /* Compute padding: 80 00 00 ... 00 00 + */ + + padLen = 128 - (int)(_count & 0x7f); + if (padLen <= 16) + padLen += 128; + + pad = new byte[padLen]; + pad[0] = 0x80; + + // Convert count to bit count + bitCount = _count * 8; + + // If we ever have UInt128 for bitCount, then these need to be uncommented. + // Note that C# only looks at the low 6 bits of the shift value for ulongs, + // so >>0 and >>64 are equal! + + //pad[padLen-16] = (byte) ((bitCount >> 120) & 0xff); + //pad[padLen-15] = (byte) ((bitCount >> 112) & 0xff); + //pad[padLen-14] = (byte) ((bitCount >> 104) & 0xff); + //pad[padLen-13] = (byte) ((bitCount >> 96) & 0xff); + //pad[padLen-12] = (byte) ((bitCount >> 88) & 0xff); + //pad[padLen-11] = (byte) ((bitCount >> 80) & 0xff); + //pad[padLen-10] = (byte) ((bitCount >> 72) & 0xff); + //pad[padLen-9] = (byte) ((bitCount >> 64) & 0xff); + pad[padLen - 8] = (byte)((bitCount >> 56) & 0xff); + pad[padLen - 7] = (byte)((bitCount >> 48) & 0xff); + pad[padLen - 6] = (byte)((bitCount >> 40) & 0xff); + pad[padLen - 5] = (byte)((bitCount >> 32) & 0xff); + pad[padLen - 4] = (byte)((bitCount >> 24) & 0xff); + pad[padLen - 3] = (byte)((bitCount >> 16) & 0xff); + pad[padLen - 2] = (byte)((bitCount >> 8) & 0xff); + pad[padLen - 1] = (byte)((bitCount >> 0) & 0xff); + + /* Digest padding */ + HashCore(pad, 0, pad.Length); + + /* Store digest */ + SHAUtils.QuadWordToBigEndian(hash, _stateSHA512, 8); + + return hash; + } + + private static readonly ulong[] _K = { + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, + 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, + 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, + 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, + 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, + }; + + private static unsafe void SHATransform(ulong* expandedBuffer, ulong* state, byte* block) + { + ulong a, b, c, d, e, f, g, h; + ulong aa, bb, cc, dd, ee, ff, hh, gg; + ulong T1; + + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + f = state[5]; + g = state[6]; + h = state[7]; + + // fill in the first 16 blocks of W. + SHAUtils.QuadWordFromBigEndian(expandedBuffer, 16, block); + SHA512Expand(expandedBuffer); + + /* Apply the SHA512 compression function */ + // We are trying to be smart here and avoid as many copies as we can + // The perf gain with this method over the straightforward modify and shift + // forward is >= 20%, so it's worth the pain + for (int j = 0; j < 80;) + { + T1 = h + Sigma_1(e) + Ch(e, f, g) + _K[j] + expandedBuffer[j]; + ee = d + T1; + aa = T1 + Sigma_0(a) + Maj(a, b, c); + j++; + + T1 = g + Sigma_1(ee) + Ch(ee, e, f) + _K[j] + expandedBuffer[j]; + ff = c + T1; + bb = T1 + Sigma_0(aa) + Maj(aa, a, b); + j++; + + T1 = f + Sigma_1(ff) + Ch(ff, ee, e) + _K[j] + expandedBuffer[j]; + gg = b + T1; + cc = T1 + Sigma_0(bb) + Maj(bb, aa, a); + j++; + + T1 = e + Sigma_1(gg) + Ch(gg, ff, ee) + _K[j] + expandedBuffer[j]; + hh = a + T1; + dd = T1 + Sigma_0(cc) + Maj(cc, bb, aa); + j++; + + T1 = ee + Sigma_1(hh) + Ch(hh, gg, ff) + _K[j] + expandedBuffer[j]; + h = aa + T1; + d = T1 + Sigma_0(dd) + Maj(dd, cc, bb); + j++; + + T1 = ff + Sigma_1(h) + Ch(h, hh, gg) + _K[j] + expandedBuffer[j]; + g = bb + T1; + c = T1 + Sigma_0(d) + Maj(d, dd, cc); + j++; + + T1 = gg + Sigma_1(g) + Ch(g, h, hh) + _K[j] + expandedBuffer[j]; + f = cc + T1; + b = T1 + Sigma_0(c) + Maj(c, d, dd); + j++; + + T1 = hh + Sigma_1(f) + Ch(f, g, h) + _K[j] + expandedBuffer[j]; + e = dd + T1; + a = T1 + Sigma_0(b) + Maj(b, c, d); + j++; + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; + } + + private static ulong RotateRight(ulong x, int n) + { + return (((x) >> (n)) | ((x) << (64 - (n)))); + } + + private static ulong Ch(ulong x, ulong y, ulong z) + { + return ((x & y) ^ ((x ^ 0xffffffffffffffff) & z)); + } + + private static ulong Maj(ulong x, ulong y, ulong z) + { + return ((x & y) ^ (x & z) ^ (y & z)); + } + + private static ulong Sigma_0(ulong x) + { + return (RotateRight(x, 28) ^ RotateRight(x, 34) ^ RotateRight(x, 39)); + } + + private static ulong Sigma_1(ulong x) + { + return (RotateRight(x, 14) ^ RotateRight(x, 18) ^ RotateRight(x, 41)); + } + + private static ulong sigma_0(ulong x) + { + return (RotateRight(x, 1) ^ RotateRight(x, 8) ^ (x >> 7)); + } + + private static ulong sigma_1(ulong x) + { + return (RotateRight(x, 19) ^ RotateRight(x, 61) ^ (x >> 6)); + } + + /* This function creates W_16,...,W_79 according to the formula + W_j <- sigma_1(W_{j-2}) + W_{j-7} + sigma_0(W_{j-15}) + W_{j-16}; + */ + private static unsafe void SHA512Expand(ulong* x) + { + for (int i = 16; i < 80; i++) + { + x[i] = sigma_1(x[i - 2]) + x[i - 7] + sigma_0(x[i - 15]) + x[i - 16]; + } + } + } + + // ported from https://github.com/microsoft/referencesource/blob/a48449cb48a9a693903668a71449ac719b76867c/mscorlib/system/security/cryptography/utils.cs + private class SHAUtils + { + // digits == number of DWORDs + public static unsafe void DWORDFromBigEndian(uint* x, int digits, byte* block) + { + int i; + int j; + + for (i = 0, j = 0; i < digits; i++, j += 4) + x[i] = (uint)((block[j] << 24) | (block[j + 1] << 16) | (block[j + 2] << 8) | block[j + 3]); + } + + // encodes x (DWORD) into block (unsigned char), most significant byte first. + // digits == number of DWORDs + public static void DWORDToBigEndian(byte[] block, uint[] x, int digits) + { + int i; + int j; + + for (i = 0, j = 0; i < digits; i++, j += 4) + { + block[j] = (byte)((x[i] >> 24) & 0xff); + block[j + 1] = (byte)((x[i] >> 16) & 0xff); + block[j + 2] = (byte)((x[i] >> 8) & 0xff); + block[j + 3] = (byte)(x[i] & 0xff); + } + } + + // digits == number of QWORDs + public static unsafe void QuadWordFromBigEndian(ulong* x, int digits, byte* block) + { + int i; + int j; + + for (i = 0, j = 0; i < digits; i++, j += 8) + x[i] = ( + (((ulong)block[j]) << 56) | (((ulong)block[j + 1]) << 48) | + (((ulong)block[j + 2]) << 40) | (((ulong)block[j + 3]) << 32) | + (((ulong)block[j + 4]) << 24) | (((ulong)block[j + 5]) << 16) | + (((ulong)block[j + 6]) << 8) | ((ulong)block[j + 7]) + ); + } + + // encodes x (DWORD) into block (unsigned char), most significant byte first. + // digits = number of QWORDS + public static void QuadWordToBigEndian(byte[] block, ulong[] x, int digits) + { + int i; + int j; + + for (i = 0, j = 0; i < digits; i++, j += 8) + { + block[j] = (byte)((x[i] >> 56) & 0xff); + block[j + 1] = (byte)((x[i] >> 48) & 0xff); + block[j + 2] = (byte)((x[i] >> 40) & 0xff); + block[j + 3] = (byte)((x[i] >> 32) & 0xff); + block[j + 4] = (byte)((x[i] >> 24) & 0xff); + block[j + 5] = (byte)((x[i] >> 16) & 0xff); + block[j + 6] = (byte)((x[i] >> 8) & 0xff); + block[j + 7] = (byte)(x[i] & 0xff); + } + } + } + } +} diff --git a/build-dotnet-tarball b/build-dotnet-tarball new file mode 100755 index 0000000..6135973 --- /dev/null +++ b/build-dotnet-tarball @@ -0,0 +1,175 @@ +#!/bin/bash + +# Usage: +# build-dotnet-tarball [--bootstrap] +# +# Creates a source archive from a tag (or commit) at github.com/dotnet/source-build + +# Source-build is a little strange, we need to clone it, check out the +# tag, build it and then create a tarball from the archive directory +# it creates. Also, it is likely that the source archive is only +# buildable on the OS it was initially created in. + +set -euo pipefail +IFS=$'\n\t' + +function print_usage { + echo "Usage:" + echo "$0 [--bootstrap] " + echo + echo "Creates a source archive from a tag at https://github.com/dotnet/source-build" + echo "" + echo " --bootstrap build a source tarball usable for bootstrapping .NET" +} + +function clean_dotnet_cache { + rm -rf ~/.aspnet ~/.dotnet/ ~/.nuget/ ~/.local/share/NuGet ~/.templateengine + rm -rf /tmp/NuGet /tmp/NuGetScratch /tmp/.NETCore* /tmp/.NETStandard* /tmp/.dotnet /tmp/dotnet.* /tmp/clr-debug-pipe* /tmp/Razor-Server /tmp/CoreFxPipe* /tmp/VBCSCompiler /tmp/.NETFramework* +} + +function check_bootstrap_environment { + if rpm -qa | grep libunwind-devel; then + echo "error: libunwind-devel is installed. Not a good idea for bootstrapping." + exit 1 + fi + if rpm -qa | grep dotnet ; then + echo "error: dotnet is installed. Not a good idea for bootstrapping." + exit 1 + fi + if [ -d /usr/lib/dotnet ] || [ -d /usr/lib64/dotnet ] || [ -d /usr/share/dotnet ] ; then + echo "error: one of /usr/lib/dotnet /usr/lib64/dotnet or /usr/share/dotnet/ exists. Not a good idea for bootstrapping." + exit 1 + fi + if command -v dotnet ; then + echo "error: dotnet is in $PATH. Not a good idea for bootstrapping." + exit 1 + fi +} + +function runtime_id { + + source /etc/os-release + case "${ID}" in + # Remove the RHEL minor version + rhel) rid_version=${VERSION_ID%.*} ;; + + *) rid_version=${VERSION_ID} ;; + esac + + echo "${ID}.${rid_version}-${arch}" +} + +build_bootstrap=false + +declare -A archmap +archmap=( + ["aarch64"]="arm64" + ["amd64"]="x64" + ["armv8l"]="arm" + ["i686"]="x86" + ["i386"]="x86" + ["x86_64"]="x64" +) + +arch=${archmap["$(uname -m)"]} + + +positional_args=() +while [[ "$#" -gt 0 ]]; do + arg="${1}" + case "${arg}" in + --bootstrap) + build_bootstrap=true + shift + ;; + -h|--help) + print_usage + exit 0 + ;; + *) + positional_args+=("$1") + shift + ;; + esac +done + + +tag=${positional_args[0]:-} +if [[ -z ${tag} ]]; then + echo "error: missing tag to build" + exit 1 +fi + +set -x + +dir_name="dotnet-${tag}" +unmodified_tarball_name="${dir_name}-original" +tarball_name="${dir_name}" + +if [[ ${build_bootstrap} == true ]]; then + unmodified_tarball_name="${unmodified_tarball_name}-${arch}-bootstrap" + tarball_name="${tarball_name}-${arch}-bootstrap" +fi + +if [ -f "${tarball_name}.tar.gz" ]; then + echo "error: ${tarball_name}.tar.gz already exists" + exit 1 +fi + +if [ ! -f "${unmodified_tarball_name}.tar.gz" ]; then + temp_dir=$(mktemp -d -p "$(pwd)") + pushd "${temp_dir}" + git clone https://github.com/dotnet/source-build + pushd source-build + git checkout "${tag}" + git submodule update --init --recursive + clean_dotnet_cache + # FIXME remove contineuonprebuilterror + ./build.sh -p:SkipPrebuiltEnforcement=true -p:ContinueOnPrebuiltBaselineError=true -p:ArchiveDownloadedPackages=true -p:UseSystemLibraries=true -p:UseSystemLibunwind=false + ./build-source-tarball.sh "${unmodified_tarball_name}" --skip-build -- -p:ContinueOnPrebuiltBaselineError=true -p:SkipPrebuiltEnforcement=true + + if [[ ${build_bootstrap} == true ]]; then + cp -a artifacts/"${arch}"/Release/Private.SourceBuilt.Artifacts.*.tar.gz "${unmodified_tarball_name}"/packages/archive/Private.SourceBuilt.Artifacts.*.tar.gz + fi + popd + popd + + tar czf "${unmodified_tarball_name}.tar.gz" -C "${temp_dir}/source-build" "${unmodified_tarball_name}" + + rm -rf "${temp_dir}" +fi + +rm -rf "${tarball_name}" +tar xf "${unmodified_tarball_name}.tar.gz" +mv "${unmodified_tarball_name}" "${tarball_name}" + +pushd "${tarball_name}" + +if [[ ${build_bootstrap} != true ]]; then + find . -type f -iname '*.tar.gz' -delete + rm -rf .dotnet +fi + +# Remove files with funny licenses, crypto implementations and other +# not-very-useful artifacts to reduce tarball size +rm -r src/aspnetcore.*/src/SignalR/clients/java/signalr/gradle* +find src/aspnetcore.*/src -type d -name samples -print0 | xargs -0 rm -r +rm -r src/NuGet.Client.*/test/EndToEnd +rm -r src/runtime.*/src/mono/ +rm -r src/Humanizer.*/samples/ + +# FIXME delete when upstream has a new release with this file fixed +if ! grep "RSA Data Security" src/runtime.*/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/SHAHashProvider.Browser.cs; then + echo "SHAHashProvider.Browser.cs has been fixed upstream. Please fix build-dotnet-tarball" + exit 1 +fi +# Delete the bad source +rm src/runtime.*/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/SHAHashProvider.Browser.cs +# Delete the patch that modifies the bad source +rm patches/runtime/0001-Use-substitute-SHA-1-implementation-in-wasm-44982.patch +# Add pre-patched copy +cp ../SHAHashProvider.Browser.cs src/runtime.*/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/ + +popd + +tar czf "${tarball_name}.tar.gz" "${tarball_name}" diff --git a/check-debug-symbols.py b/check-debug-symbols.py new file mode 100755 index 0000000..be26d87 --- /dev/null +++ b/check-debug-symbols.py @@ -0,0 +1,136 @@ +#!/usr/bin/python3 + +""" +Check debug symbols are present in shared object and can identify +code. + +It starts scanning from a directory and recursively scans all ELF +files found in it for various symbols to ensure all debuginfo is +present and nothing has been stripped. + +Usage: + +./check-debug-symbols /path/of/dir/to/scan/ + + +Example: + +./check-debug-symbols /usr/lib64 +""" + +# This technique was explained to me by Mark Wielaard (mjw). + +import collections +import os +import re +import subprocess +import sys + +ScanResult = collections.namedtuple('ScanResult', + 'file_name debug_info debug_abbrev file_symbols gnu_debuglink') + + +def scan_file(file): + "Scan the provided file and return a ScanResult containing results of the scan." + + # Test for .debug_* sections in the shared object. This is the main test. + # Stripped objects will not contain these. + readelf_S_result = subprocess.run(['eu-readelf', '-S', file], + stdout=subprocess.PIPE, encoding='utf-8', check=True) + has_debug_info = any(line for line in readelf_S_result.stdout.split('\n') if '] .debug_info' in line) + + has_debug_abbrev = any(line for line in readelf_S_result.stdout.split('\n') if '] .debug_abbrev' in line) + + # Test FILE symbols. These will most likely be removed by anyting that + # manipulates symbol tables because it's generally useless. So a nice test + # that nothing has messed with symbols. + def contains_file_symbols(line): + parts = line.split() + if len(parts) < 8: + return False + return \ + parts[2] == '0' and parts[3] == 'FILE' and parts[4] == 'LOCAL' and parts[5] == 'DEFAULT' and \ + parts[6] == 'ABS' and re.match(r'((.*/)?[-_a-zA-Z0-9]+\.(c|cc|cpp|cxx))?', parts[7]) + + readelf_s_result = subprocess.run(["eu-readelf", '-s', file], + stdout=subprocess.PIPE, encoding='utf-8', check=True) + has_file_symbols = any(line for line in readelf_s_result.stdout.split('\n') if contains_file_symbols(line)) + + # Test that there are no .gnu_debuglink sections pointing to another + # debuginfo file. There shouldn't be any debuginfo files, so the link makes + # no sense either. + has_gnu_debuglink = any(line for line in readelf_s_result.stdout.split('\n') if '] .gnu_debuglink' in line) + + return ScanResult(file, has_debug_info, has_debug_abbrev, has_file_symbols, has_gnu_debuglink) + +def is_elf(file): + result = subprocess.run(['file', file], stdout=subprocess.PIPE, encoding='utf-8', check=True) + return re.search('ELF 64-bit LSB (?:executable|shared object)', result.stdout) + +def scan_file_if_sensible(file): + if is_elf(file): + # print(file) + return scan_file(file) + return None + +def scan_dir(dir): + results = [] + for root, _, files in os.walk(dir): + for name in files: + result = scan_file_if_sensible(os.path.join(root, name)) + if result: + results.append(result) + return results + +def scan(file): + file = os.path.abspath(file) + if os.path.isdir(file): + return scan_dir(file) + elif os.path.isfile(file): + return [scan_file_if_sensible(file)] + +def is_bad_result(result): + return not result.debug_info or not result.debug_abbrev or not result.file_symbols or result.gnu_debuglink + +def print_scan_results(results, verbose): + # print(results) + for result in results: + file_name = result.file_name + found_issue = False + if not result.debug_info: + found_issue = True + print('error: missing .debug_info section in', file_name) + if not result.debug_abbrev: + found_issue = True + print('error: missing .debug_abbrev section in', file_name) + if not result.file_symbols: + found_issue = True + print('error: missing FILE symbols in', file_name) + if result.gnu_debuglink: + found_issue = True + print('error: unexpected .gnu_debuglink section in', file_name) + if verbose and not found_issue: + print('OK: ', file_name) + +def main(args): + verbose = False + files = [] + for arg in args: + if arg == '--verbose' or arg == '-v': + verbose = True + else: + files.append(arg) + + results = [] + for file in files: + results.extend(scan(file)) + + print_scan_results(results, verbose) + + if any(is_bad_result(result) for result in results): + return 1 + return 0 + + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) diff --git a/copr-build b/copr-build new file mode 100755 index 0000000..8a7cf46 --- /dev/null +++ b/copr-build @@ -0,0 +1,11 @@ +#!/bin/bash + +set -euo pipefail + +set -x + +fedpkg --release f32 srpm 2>&1 | tee fedpkg.output + +srpm_name=$(grep 'Wrote: ' fedpkg.output | cut -d' ' -f 2) + +copr-cli build @dotnet-sig/dotnet-preview "${srpm_name}" diff --git a/dotnet.sh.in b/dotnet.sh.in new file mode 100644 index 0000000..65b92a0 --- /dev/null +++ b/dotnet.sh.in @@ -0,0 +1,14 @@ + +# Set location for AppHost lookup +[ -z "$DOTNET_ROOT" ] && export DOTNET_ROOT=@LIBDIR@/dotnet + +# Add dotnet tools directory to PATH +DOTNET_TOOLS_PATH="$HOME/.dotnet/tools" +case "$PATH" in + *"$DOTNET_TOOLS_PATH"* ) true ;; + * ) PATH="$PATH:$DOTNET_TOOLS_PATH" ;; +esac + +# Extract self-contained executables under HOME +# to avoid multi-user issues from using the default '/var/tmp'. +[ -z "$DOTNET_BUNDLE_EXTRACT_BASE_DIR" ] && export DOTNET_BUNDLE_EXTRACT_BASE_DIR="${XDG_CACHE_HOME:-"$HOME"/.cache}/dotnet_bundle_extract" diff --git a/dotnet5.0.spec b/dotnet5.0.spec new file mode 100644 index 0000000..6d2e962 --- /dev/null +++ b/dotnet5.0.spec @@ -0,0 +1,787 @@ +%bcond_without bootstrap + +# Avoid provides/requires from private libraries +%global privlibs libhostfxr +%global privlibs %{privlibs}|libclrjit +%global privlibs %{privlibs}|libcoreclr +%global privlibs %{privlibs}|libcoreclrtraceptprovider +%global privlibs %{privlibs}|libdbgshim +%global privlibs %{privlibs}|libhostpolicy +%global privlibs %{privlibs}|libmscordaccore +%global privlibs %{privlibs}|libmscordbi +%global privlibs %{privlibs}|libsos +%global privlibs %{privlibs}|libsosplugin +%global __provides_exclude ^(%{privlibs})\\.so +%global __requires_exclude ^(%{privlibs})\\.so + +# LTO triggers a compilation error for a source level issue. Given that LTO should not +# change the validity of any given source and the nature of the error (undefined enum), I +# suspect a generator program is mis-behaving in some way. This needs further debugging, +# until that's done, disable LTO. This has to happen before setting the flags below. +%define _lto_cflags %{nil} + +%global host_version 5.0.2 +%global runtime_version 5.0.2 +%global aspnetcore_runtime_version 5.0.2 +%global sdk_version 5.0.102 +%global templates_version %{runtime_version} +#%%global templates_version %%(echo %%{runtime_version} | awk 'BEGIN { FS="."; OFS="." } {print $1, $2, $3+1 }') + +%global host_rpm_version %{host_version} +%global aspnetcore_runtime_rpm_version %{aspnetcore_runtime_version} +%global runtime_rpm_version %{runtime_version} +%global sdk_rpm_version %{sdk_version} + +# upstream can update releases without revving the SDK version so these don't always match +%global src_version %{sdk_version} + +%if 0%{?fedora} || 0%{?rhel} < 8 +%global use_bundled_libunwind 0 +%else +%global use_bundled_libunwind 1 +%endif + +%ifarch aarch64 +%global use_bundled_libunwind 1 +%endif + +%ifarch x86_64 +%global runtime_arch x64 +%endif +%ifarch aarch64 +%global runtime_arch arm64 +%endif + +%{!?runtime_id:%global runtime_id %(. /etc/os-release ; echo "${ID}.${VERSION_ID%%.*}")-%{runtime_arch}} + +Name: dotnet5.0 +Version: %{sdk_rpm_version} +Release: 1%{?dist} +Summary: .NET Runtime and SDK +License: MIT and ASL 2.0 and BSD and LGPLv2+ and CC-BY and CC0 and MS-PL and EPL-1.0 and GPL+ and GPLv2 and ISC and OFL and zlib +URL: https://github.com/dotnet/ + +# The source is generated on a Fedora box via: +# ./build-dotnet-tarball v%%{src_version}-SDK +Source0: dotnet-v%{src_version}-SDK-x64-bootstrap.tar.gz +Source1: dotnet-v%{src_version}-SDK-arm64-bootstrap.tar.gz + +Source10: check-debug-symbols.py +Source11: dotnet.sh.in + +# Fix up a patch included in source-build to apply after we apply the linker-order patch first +Patch1: source-build-runtime-fixup-linker-order.patch + +# https://github.com/dotnet/runtime/pull/42094 +# Fix linker order when linking with --as-needed +Patch100: runtime-linker-order.patch +# https://github.com/dotnet/runtime/pull/47020 +# Fix build with gcc 11 +Patch101: runtime-47020-gcc11.patch + +# Disable telemetry by default; make it opt-in +Patch500: sdk-telemetry-optout.patch + +%if 0%{?fedora} > 32 || 0%{?rhel} > 8 +ExclusiveArch: aarch64 x86_64 +%else +ExclusiveArch: x86_64 +%endif + + +BuildRequires: clang +BuildRequires: cmake +BuildRequires: coreutils +%if %{without bootstrap} +BuildRequires: dotnet5.0-build-reference-packages +BuildRequires: dotnet-sdk-5.0 +BuildRequires: dotnet-sdk-5.0-source-built-artifacts +%endif +BuildRequires: findutils +BuildRequires: git +%if 0%{?fedora} || 0%{?rhel} > 7 +BuildRequires: glibc-langpack-en +%endif +BuildRequires: hostname +BuildRequires: krb5-devel +BuildRequires: libcurl-devel +BuildRequires: libicu-devel +%if ! %{use_bundled_libunwind} +BuildRequires: libunwind-devel +%endif +BuildRequires: lldb-devel +BuildRequires: llvm +BuildRequires: lttng-ust-devel +BuildRequires: make +BuildRequires: openssl-devel +BuildRequires: python3 +BuildRequires: systemtap-sdt-devel +BuildRequires: tar +BuildRequires: zlib-devel + +%description +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, macOS and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + +.NET contains a runtime conforming to .NET Standards a set of +framework libraries, an SDK containing compilers and a 'dotnet' +application to drive everything. + + +%package -n dotnet + +Version: %{sdk_rpm_version} +Summary: .NET CLI tools and runtime + +Requires: dotnet-sdk-5.0%{?_isa} >= %{sdk_rpm_version}-%{release} + +%description -n dotnet +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, macOS and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + +.NET contains a runtime conforming to .NET Standards a set of +framework libraries, an SDK containing compilers and a 'dotnet' +application to drive everything. + + +%package -n dotnet-host + +Version: %{host_rpm_version} +Summary: .NET command line launcher + +%description -n dotnet-host +The .NET host is a command line program that runs a standalone +.NET application or launches the SDK. + +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%package -n dotnet-hostfxr-5.0 + +Version: %{host_rpm_version} +Summary: .NET command line host resolver + +# Theoretically any version of the host should work. But lets aim for the one +# provided by this package, or from a newer version of .NET +Requires: dotnet-host%{?_isa} >= %{host_rpm_version}-%{release} + +%description -n dotnet-hostfxr-5.0 +The .NET host resolver contains the logic to resolve and select +the right version of the .NET SDK or runtime to use. + +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%package -n dotnet-runtime-5.0 + +Version: %{runtime_rpm_version} +Summary: NET 5.0 runtime + +Requires: dotnet-hostfxr-5.0%{?_isa} >= %{host_rpm_version}-%{release} + +# libicu is dlopen()ed +Requires: libicu%{?_isa} + +%if %{use_bundled_libunwind} +Provides: bundled(libunwind) = 1.3 +%endif + +%description -n dotnet-runtime-5.0 +The .NET runtime contains everything needed to run .NET applications. +It includes a high performance Virtual Machine as well as the framework +libraries used by .NET applications. + +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%package -n aspnetcore-runtime-5.0 + +Version: %{aspnetcore_runtime_rpm_version} +Summary: ASP.NET Core 5.0 runtime + +Requires: dotnet-runtime-5.0%{?_isa} >= %{runtime_rpm_version}-%{release} + +%description -n aspnetcore-runtime-5.0 +The ASP.NET Core runtime contains everything needed to run .NET +web applications. It includes a high performance Virtual Machine as +well as the framework libraries used by .NET applications. + +ASP.NET Core is a fast, lightweight and modular platform for creating +cross platform web applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%package -n dotnet-templates-5.0 + +Version: %{sdk_rpm_version} +Summary: .NET 5.0 templates + +# Theoretically any version of the host should work. But lets aim for the one +# provided by this package, or from a newer version of .NET +Requires: dotnet-host%{?_isa} >= %{host_rpm_version}-%{release} + +%description -n dotnet-templates-5.0 +This package contains templates used by the .NET SDK. + +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%package -n dotnet-sdk-5.0 + +Version: %{sdk_rpm_version} +Summary: .NET 5.0 Software Development Kit + +Provides: bundled(js-jquery) +Provides: bundled(npm) + +Requires: dotnet-runtime-5.0%{?_isa} >= %{runtime_rpm_version}-%{release} +Requires: aspnetcore-runtime-5.0%{?_isa} >= %{aspnetcore_runtime_rpm_version}-%{release} + +Requires: dotnet-apphost-pack-5.0%{?_isa} >= %{runtime_rpm_version}-%{release} +Requires: dotnet-targeting-pack-5.0%{?_isa} >= %{runtime_rpm_version}-%{release} +Requires: aspnetcore-targeting-pack-5.0%{?_isa} >= %{aspnetcore_runtime_rpm_version}-%{release} +Requires: netstandard-targeting-pack-2.1%{?_isa} >= %{sdk_rpm_version}-%{release} + +Requires: dotnet-templates-5.0%{?_isa} >= %{sdk_rpm_version}-%{release} + +%description -n dotnet-sdk-5.0 +The .NET SDK is a collection of command line applications to +create, build, publish and run .NET applications. + +.NET is a fast, lightweight and modular platform for creating +cross platform applications that work on Linux, Mac and Windows. + +It particularly focuses on creating console applications, web +applications and micro-services. + + +%global dotnet_targeting_pack() %{expand: +%package -n %{1} + +Version: %{2} +Summary: Targeting Pack for %{3} %{4} + +Requires: dotnet-host%{?_isa} + +%description -n %{1} +This package provides a targeting pack for %{3} %{4} +that allows developers to compile against and target %{3} %{4} +applications using the .NET SDK. + +%files -n %{1} +%dir %{_libdir}/dotnet/packs +%{_libdir}/dotnet/packs/%{5} +} + +%dotnet_targeting_pack dotnet-apphost-pack-5.0 %{runtime_rpm_version} Microsoft.NETCore.App 5.0 Microsoft.NETCore.App.Host.%{runtime_id} +%dotnet_targeting_pack dotnet-targeting-pack-5.0 %{runtime_rpm_version} Microsoft.NETCore.App 5.0 Microsoft.NETCore.App.Ref +%dotnet_targeting_pack aspnetcore-targeting-pack-5.0 %{aspnetcore_runtime_rpm_version} Microsoft.AspNetCore.App 5.0 Microsoft.AspNetCore.App.Ref +%dotnet_targeting_pack netstandard-targeting-pack-2.1 %{sdk_rpm_version} NETStandard.Library 2.1 NETStandard.Library.Ref + + +%package -n dotnet-sdk-5.0-source-built-artifacts + +Version: %{sdk_rpm_version} +Summary: Internal package for building .NET 5.0 Software Development Kit + +%description -n dotnet-sdk-5.0-source-built-artifacts +The .NET source-built archive is a collection of packages needed +to build the .NET SDK itself. + +These are not meant for general use. + + +%prep +%if %{without bootstrap} +%setup -q -n dotnet-v%{src_version}-SDK +%else +%ifarch x86_64 +%setup -q -T -b 0 -n dotnet-v%{src_version}-SDK-%{runtime_arch}-bootstrap +%endif +%ifarch aarch64 +%setup -q -T -b 1 -n dotnet-v%{src_version}-SDK-%{runtime_arch}-bootstrap +%endif +%endif + +%if %{without bootstrap} +# Remove all prebuilts +find -iname '*.dll' -type f -delete +find -iname '*.so' -type f -delete +find -iname '*.tar.gz' -type f -delete +find -iname '*.nupkg' -type f -delete +find -iname '*.zip' -type f -delete +rm -rf .dotnet/ +rm -rf packages/source-built +%endif + +%if %{without bootstrap} +mkdir -p packages/archive +ln -s %{_libdir}/dotnet/source-built-artifacts/*.tar.gz packages/archive/ +ln -s %{_libdir}/dotnet/reference-packages/*.tar.gz packages/archive +%endif + +# Fix bad hardcoded path in build +sed -i 's|/usr/share/dotnet|%{_libdir}/dotnet|' src/runtime.*/src/installer/corehost/cli/hostmisc/pal.unix.cpp + +# Disable warnings +sed -i 's|skiptests|skiptests ignorewarnings|' repos/runtime.common.props + +%patch1 -p1 + +pushd src/runtime.* +%patch100 -p1 +%patch101 -p1 +popd + +pushd src/sdk.* +%patch500 -p1 +popd + +%if %{without bootstrap} +%ifnarch x86_64 +mkdir -p artifacts/obj/%{runtime_arch}/Release +cp artifacts/obj/x64/Release/PackageVersions.props artifacts/obj/%{runtime_arch}/Release/PackageVersions.props +%endif +%endif + +cat source-build-info.txt + +find -iname 'nuget.config' -exec echo {}: \; -exec cat {} \; -exec echo \; + + +%build +cat /etc/os-release + +%if %{without bootstrap} +# We need to create a copy because we will mutate this +cp -a %{_libdir}/dotnet previously-built-dotnet +%endif + +%if 0%{?fedora} > 32 || 0%{?rhel} > 8 +# Setting this macro ensures that only clang supported options will be +# added to ldflags and cflags. +%global toolchain clang +%set_build_flags +%else +# Filter flags not supported by clang +%global dotnet_cflags %(echo %optflags | sed -re 's/-specs=[^ ]*//g') +%global dotnet_ldflags %(echo %{__global_ldflags} | sed -re 's/-specs=[^ ]*//g') +export CFLAGS="%{dotnet_cflags}" +export CXXFLAGS="%{dotnet_cflags}" +export LDFLAGS="%{dotnet_ldflags}" +%endif + +%ifarch aarch64 +# -mbranch-protection=standard breaks unwinding in CoreCLR through libunwind +CFLAGS=$(echo $CFLAGS | sed -e 's/-mbranch-protection=standard //') +CXXFLAGS=$(echo $CXXFLAGS | sed -e 's/-mbranch-protection=standard //') +%endif + +# -fstack-clash-protection breaks CoreCLR +CFLAGS=$(echo $CFLAGS | sed -e 's/-fstack-clash-protection//' ) +CXXFLAGS=$(echo $CXXFLAGS | sed -e 's/-fstack-clash-protection//' ) + +export EXTRA_CFLAGS="$CFLAGS" +export EXTRA_CXXFLAGS="$CXXFLAGS" +export EXTRA_LDFLAGS="$LDFLAGS" + +unset CFLAGS +unset CXXFLAGS +unset LDFLAGS + +#%%if %%{without bootstrap} +# --with-ref-packages %%{_libdir}/dotnet/reference-packages/ \ +# --with-packages %%{_libdir}/dotnet/source-built-artifacts/*.tar.gz \ +# --with-sdk %%{_libdir}/dotnet \ +#%%endif + +VERBOSE=1 ./build.sh \ +%if %{without bootstrap} + --with-sdk previously-built-dotnet \ +%endif + -- \ + /v:n \ + /p:SkipPortableRuntimeBuild=true \ + /p:LogVerbosity=n \ + /p:MinimalConsoleLogOutput=false \ + /p:ContinueOnPrebuiltBaselineError=true \ +%if %{use_bundled_libunwind} + /p:UseSystemLibunwind=false \ +%else + /p:UseSystemLibunwind=true \ +%endif + + +sed -e 's|[@]LIBDIR[@]|%{_libdir}|g' %{SOURCE11} > dotnet.sh + + +%install +install -dm 0755 %{buildroot}%{_libdir}/dotnet +ls artifacts/%{runtime_arch}/Release +tar xf artifacts/%{runtime_arch}/Release/dotnet-sdk-%{sdk_version}-%{runtime_id}.tar.gz -C %{buildroot}%{_libdir}/dotnet/ + +# Install managed symbols +tar xf artifacts/%{runtime_arch}/Release/runtime/dotnet-runtime-symbols-%{runtime_version}-%{runtime_id}.tar.gz \ + -C %{buildroot}/%{_libdir}/dotnet/shared/Microsoft.NETCore.App/%{runtime_version}/ + +# Fix executable permissions on files +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.a' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.dll' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.h' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.pdb' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.props' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.pubxml' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.targets' -exec chmod -x {} \; +find %{buildroot}%{_libdir}/dotnet/ -type f -name '*.xml' -exec chmod -x {} \; +chmod 0755 %{buildroot}/%{_libdir}/dotnet/sdk/%{sdk_version}/AppHostTemplate/apphost +chmod 0755 %{buildroot}/%{_libdir}/dotnet/packs/Microsoft.NETCore.App.Host.%{runtime_id}/%{runtime_version}/runtimes/%{runtime_id}/native/apphost +chmod 0755 %{buildroot}/%{_libdir}/dotnet/packs/Microsoft.NETCore.App.Host.%{runtime_id}/%{runtime_version}/runtimes/%{runtime_id}/native/libnethost.so +chmod 0644 %{buildroot}/%{_libdir}/dotnet/packs/Microsoft.NETCore.App.Host.%{runtime_id}/%{runtime_version}/runtimes/%{runtime_id}/native/nethost.h +chmod 0755 %{buildroot}/%{_libdir}/dotnet/packs/Microsoft.NETCore.App.Host.%{runtime_id}/%{runtime_version}/runtimes/%{runtime_id}/native/singlefilehost + +install -dm 0755 %{buildroot}%{_sysconfdir}/profile.d/ +install dotnet.sh %{buildroot}%{_sysconfdir}/profile.d/ + +install -dm 0755 %{buildroot}/%{_datadir}/bash-completion/completions +# dynamic completion needs the file to be named the same as the base command +install src/sdk.*/scripts/register-completions.bash %{buildroot}/%{_datadir}/bash-completion/completions/dotnet + +# TODO: the zsh completion script needs to be ported to use #compdef +#install -dm 755 %%{buildroot}/%%{_datadir}/zsh/site-functions +#install src/cli/scripts/register-completions.zsh %%{buildroot}/%%{_datadir}/zsh/site-functions/_dotnet + +install -dm 0755 %{buildroot}%{_bindir} +ln -s ../../%{_libdir}/dotnet/dotnet %{buildroot}%{_bindir}/ + +install -dm 0755 %{buildroot}%{_mandir}/man1/ +find -iname 'dotnet*.1' -type f -exec cp {} %{buildroot}%{_mandir}/man1/ \; + +echo "%{_libdir}/dotnet" >> install_location +install -dm 0755 %{buildroot}%{_sysconfdir}/dotnet +install install_location %{buildroot}%{_sysconfdir}/dotnet/ + +install -dm 0755 %{buildroot}%{_libdir}/dotnet/source-built-artifacts +install artifacts/%{runtime_arch}/Release/Private.SourceBuilt.Artifacts.*.tar.gz %{buildroot}/%{_libdir}/dotnet/source-built-artifacts/ + +# Check debug symbols in all elf objects. This is not in %%check +# because native binaries are stripped by rpm-build after %%install. +# So we need to do this check earlier. +echo "Testing build results for debug symbols..." +%{SOURCE10} -v %{buildroot}%{_libdir}/dotnet/ + + +%check +%{buildroot}%{_libdir}/dotnet/dotnet --info + + +%files -n dotnet +# empty package useful for dependencies + +%files -n dotnet-host +%dir %{_libdir}/dotnet +%{_libdir}/dotnet/dotnet +%dir %{_libdir}/dotnet/host +%dir %{_libdir}/dotnet/host/fxr +%{_bindir}/dotnet +%license %{_libdir}/dotnet/LICENSE.txt +%license %{_libdir}/dotnet/ThirdPartyNotices.txt +%doc %{_mandir}/man1/dotnet*.1.gz +%{_sysconfdir}/profile.d/dotnet.sh +%{_sysconfdir}/dotnet +%dir %{_datadir}/bash-completion +%dir %{_datadir}/bash-completion/completions +%{_datadir}/bash-completion/completions/dotnet + +%files -n dotnet-hostfxr-5.0 +%dir %{_libdir}/dotnet/host/fxr +%{_libdir}/dotnet/host/fxr/%{host_version} + +%files -n dotnet-runtime-5.0 +%dir %{_libdir}/dotnet/shared +%dir %{_libdir}/dotnet/shared/Microsoft.NETCore.App +%{_libdir}/dotnet/shared/Microsoft.NETCore.App/%{runtime_version} + +%files -n aspnetcore-runtime-5.0 +%dir %{_libdir}/dotnet/shared +%dir %{_libdir}/dotnet/shared/Microsoft.AspNetCore.App +%{_libdir}/dotnet/shared/Microsoft.AspNetCore.App/%{aspnetcore_runtime_version} + +%files -n dotnet-templates-5.0 +%dir %{_libdir}/dotnet/templates +%{_libdir}/dotnet/templates/%{templates_version} + +%files -n dotnet-sdk-5.0 +%dir %{_libdir}/dotnet/sdk +%{_libdir}/dotnet/sdk/%{sdk_version} +%dir %{_libdir}/dotnet/packs + +%files -n dotnet-sdk-5.0-source-built-artifacts +%dir %{_libdir}/dotnet +%{_libdir}/dotnet/source-built-artifacts + + +%changelog +* Fri Dec 18 2020 Omair Majid - 5.0.100-2 +- Update to .NET Core Runtime 5.0.0 and SDK 5.0.100 commit 9c4e5de + +* Fri Dec 04 2020 Omair Majid - 5.0.100-1 +- Update to .NET Core Runtime 5.0.0 and SDK 5.0.100 + +* Thu Dec 03 2020 Omair Majid - 5.0.100-0.4.20201202git337413b +- Update to latest 5.0 pre-GA commit + +* Tue Nov 24 2020 Omair Majid - 5.0.100-0.4.20201123gitdee899c +- Update to 5.0 pre-GA commit + +* Mon Sep 14 2020 Omair Majid - 5.0.100-0.3.preview8 +- Update to Preview 8 + +* Fri Jul 10 2020 Omair Majid - 5.0.100-0.2.preview4 +- Fix building with custom CFLAGS/CXXFLAGS/LDFLAGS +- Clean up patches + +* Mon Jul 06 2020 Omair Majid - 5.0.100-0.1.preview4 +- Initial build + +* Sat Jun 27 2020 Omair Majid - 3.1.105-4 +- Disable bootstrap + +* Fri Jun 26 2020 Omair Majid - 3.1.105-3 +- Re-bootstrap aarch64 + +* Fri Jun 19 2020 Omair Majid - 3.1.105-3 +- Disable bootstrap + +* Thu Jun 18 2020 Omair Majid - 3.1.105-1 +- Bootstrap aarch64 + +* Tue Jun 16 2020 Chris Rummel - 3.1.105-1 +- Update to .NET Core Runtime 3.1.5 and SDK 3.1.105 + +* Fri Jun 05 2020 Chris Rummel - 3.1.104-1 +- Update to .NET Core Runtime 3.1.4 and SDK 3.1.104 + +* Thu Apr 09 2020 Chris Rummel - 3.1.103-1 +- Update to .NET Core Runtime 3.1.3 and SDK 3.1.103 + +* Mon Mar 16 2020 Omair Majid - 3.1.102-1 +- Update to .NET Core Runtime 3.1.2 and SDK 3.1.102 + +* Fri Feb 28 2020 Omair Majid - 3.1.101-4 +- Disable bootstrap + +* Fri Feb 28 2020 Omair Majid - 3.1.101-3 +- Enable bootstrap +- Add Fedora 33 runtime ids + +* Thu Feb 27 2020 Omair Majid - 3.1.101-2 +- Disable bootstrap + +* Tue Jan 21 2020 Omair Majid - 3.1.101-1 +- Update to .NET Core Runtime 3.1.1 and SDK 3.1.101 + +* Thu Dec 05 2019 Omair Majid - 3.1.100-1 +- Update to .NET Core Runtime 3.1.0 and SDK 3.1.100 + +* Mon Nov 18 2019 Omair Majid - 3.1.100-0.4.preview3 +- Fix apphost permissions + +* Fri Nov 15 2019 Omair Majid - 3.1.100-0.3.preview3 +- Update to .NET Core Runtime 3.1.0-preview3.19553.2 and SDK + 3.1.100-preview3-014645 + +* Wed Nov 06 2019 Omair Majid - 3.1.100-0.2 +- Update to .NET Core 3.1 Preview 2 + +* Wed Oct 30 2019 Omair Majid - 3.1.100-0.1 +- Update to .NET Core 3.1 Preview 1 + +* Thu Oct 24 2019 Omair Majid - 3.0.100-5 +- Add cgroupv2 support to .NET Core + +* Wed Oct 16 2019 Omair Majid - 3.0.100-4 +- Include fix from coreclr for building on Fedora 32 + +* Wed Oct 16 2019 Omair Majid - 3.0.100-3 +- Harden built binaries to pass annocheck + +* Fri Oct 11 2019 Omair Majid - 3.0.100-2 +- Export DOTNET_ROOT in profile to make apphost lookup work + +* Fri Sep 27 2019 Omair Majid - 3.0.100-1 +- Update to .NET Core Runtime 3.0.0 and SDK 3.0.100 + +* Wed Sep 25 2019 Omair Majid - 3.0.100-0.18.rc1 +- Update to .NET Core Runtime 3.0.0-rc1-19456-20 and SDK 3.0.100-rc1-014190 + +* Tue Sep 17 2019 Omair Majid - 3.0.100-0.16.preview9 +- Fix files duplicated between dotnet-apphost-pack-3.0 and dotnet-targeting-pack-3.0 +- Fix dependencies between .NET SDK and the targeting packs + +* Mon Sep 16 2019 Omair Majid - 3.0.100-0.15.preview9 +- Update to .NET Core Runtime 3.0.0-preview 9 and SDK 3.0.100-preview9 + +* Mon Aug 19 2019 Omair Majid - 3.0.100-0.11.preview8 +- Update to .NET Core Runtime 3.0.0-preview8-28405-07 and SDK + 3.0.100-preview8-013656 + +* Tue Jul 30 2019 Omair Majid - 3.0.100-0.9.preview7 +- Update to .NET Core Runtime 3.0.0-preview7-27912-14 and SDK + 3.0.100-preview7-012821 + +* Fri Jul 26 2019 Omair Majid - 3.0.100-0.8.preview7 +- Update to .NET Core Runtime 3.0.0-preview7-27902-19 and SDK + 3.0.100-preview7-012802 + +* Wed Jun 26 2019 Omair Majid - 3.0.0-0.7.preview6 +- Obsolete dotnet-sdk-3.0.1xx +- Add supackages for targeting packs +- Add -fcf-protection to CFLAGS + +* Wed Jun 26 2019 Omair Majid - 3.0.0-0.6.preview6 +- Update to .NET Core Runtime 3.0.0-preview6-27804-01 and SDK 3.0.100-preview6-012264 +- Set dotnet installation location in /etc/dotnet/install_location +- Update targeting packs +- Install managed symbols +- Completely conditionalize libunwind bundling + +* Tue May 07 2019 Omair Majid - 3.0.0-0.3.preview4 +- Update to .NET Core 3.0 preview 4 + +* Tue Dec 18 2018 Omair Majid - 3.0.0-0.1.preview1 +- Update to .NET Core 3.0 preview 1 + +* Fri Dec 07 2018 Omair Majid - 2.2.100 +- Update to .NET Core 2.2.0 + +* Wed Nov 07 2018 Omair Majid - 2.2.100-0.2.preview3 +- Update to .NET Core 2.2.0-preview3 + +* Fri Nov 02 2018 Omair Majid - 2.1.403-3 +- Add host-fxr-2.1 subpackage + +* Mon Oct 15 2018 Omair Majid - 2.1.403-2 +- Disable telemetry by default +- Users have to manually export DOTNET_CLI_TELEMETRY_OPTOUT=0 to enable + +* Tue Oct 02 2018 Omair Majid - 2.1.403-1 +- Update to .NET Core Runtime 2.1.5 and SDK 2.1.403 + +* Wed Sep 26 2018 Omair Majid - 2.1.402-2 +- Add ~/.dotnet/tools to $PATH to make it easier to use dotnet tools + +* Thu Sep 13 2018 Omair Majid - 2.1.402-1 +- Update to .NET Core Runtime 2.1.4 and SDK 2.1.402 + +* Wed Sep 05 2018 Omair Majid - 2.1.401-2 +- Use distro-standard flags when building .NET Core + +* Tue Aug 21 2018 Omair Majid - 2.1.401-1 +- Update to .NET Core Runtime 2.1.3 and SDK 2.1.401 + +* Mon Aug 20 2018 Omair Majid - 2.1.302-1 +- Update to .NET Core Runtime 2.1.2 and SDK 2.1.302 + +* Fri Jul 20 2018 Omair Majid - 2.1.301-1 +- Update to .NET Core 2.1 + +* Thu May 03 2018 Omair Majid - 2.0.7-1 +- Update to .NET Core 2.0.7 + +* Wed Mar 28 2018 Omair Majid - 2.0.6-2 +- Enable bash completion for dotnet +- Remove redundant buildrequires and requires + +* Wed Mar 14 2018 Omair Majid - 2.0.6-1 +- Update to .NET Core 2.0.6 + +* Fri Feb 23 2018 Omair Majid - 2.0.5-1 +- Update to .NET Core 2.0.5 + +* Wed Jan 24 2018 Omair Majid - 2.0.3-5 +- Don't apply corefx clang warnings fix on clang < 5 + +* Fri Jan 19 2018 Omair Majid - 2.0.3-4 +- Add a test script to sanity check debug and symbol info. +- Build with clang 5.0 +- Make main package real instead of using a virtual provides (see RHBZ 1519325) + +* Wed Nov 29 2017 Omair Majid - 2.0.3-3 +- Add a Provides for 'dotnet' +- Fix conditional macro + +* Tue Nov 28 2017 Omair Majid - 2.0.3-2 +- Fix build on Fedora 27 + +* Fri Nov 17 2017 Omair Majid - 2.0.3-1 +- Update to .NET Core 2.0.3 + +* Thu Oct 19 2017 Omair Majid - 2.0.0-4 +- Add a hack to let omnisharp work + +* Wed Aug 30 2017 Omair Majid - 2.0.0-3 +- Add a patch for building coreclr and core-setup correctly on Fedora >= 27 + +* Fri Aug 25 2017 Omair Majid - 2.0.0-2 +- Move libicu/libcurl/libunwind requires to runtime package +- Make sdk depend on the exact version of the runtime package + +* Thu Aug 24 2017 Omair Majid - 2.0.0-1 +- Update to 2.0.0 final release + +* Wed Jul 26 2017 Omair Majid - 2.0.0-0.3.preview2 +- Add man pages + +* Tue Jul 25 2017 Omair Majid - 2.0.0-0.2.preview2 +- Add Requires on libicu +- Split into multiple packages +- Do not repeat first-run message + +* Fri Jul 21 2017 Omair Majid - 2.0.0-0.1.preview2 +- Update to .NET Core 2.0 Preview 2 + +* Thu Mar 16 2017 Nemanja Milošević - 1.1.0-7 +- rebuilt with latest libldb +* Wed Feb 22 2017 Nemanja Milosevic - 1.1.0-6 +- compat-openssl 1.0 for F26 for now +* Sun Feb 19 2017 Nemanja Milosevic - 1.1.0-5 +- Fix wrong commit id's +* Sat Feb 18 2017 Nemanja Milosevic - 1.1.0-4 +- Use commit id's instead of branch names +* Sat Feb 18 2017 Nemanja Milosevic - 1.1.0-3 +- Improper patch5 fix +* Sat Feb 18 2017 Nemanja Milosevic - 1.1.0-2 +- SPEC cleanup +- git removal (using all tarballs for reproducible builds) +- more reasonable versioning +* Thu Feb 09 2017 Nemanja Milosevic - 1.1.0-1 +- Fixed debuginfo going to separate package (Patch1) +- Added F25/F26 RIL and fixed the version info (Patch2) +- Added F25/F26 RIL in Microsoft.NETCore.App suported runtime graph (Patch3) +- SPEC file cleanup +* Wed Jan 11 2017 Nemanja Milosevic - 1.1.0-0 +- Initial RPM for Fedora 25/26. diff --git a/gating.yaml b/gating.yaml new file mode 100644 index 0000000..0d881de --- /dev/null +++ b/gating.yaml @@ -0,0 +1,7 @@ +--- !Policy +product_versions: + - fedora-* +decision_context: bodhi_update_push_testing +subject_type: koji_build +rules: + - !PassingTestCaseRule {test_case_name: fedora-ci.koji-build.tier0.functional} diff --git a/rename-tarball b/rename-tarball new file mode 100755 index 0000000..b6b6086 --- /dev/null +++ b/rename-tarball @@ -0,0 +1,49 @@ +#!/bin/bash + +# Usage: +# ./rename-tarball original-name.tar.gz new-name.tar.gz + +set -euo pipefail +IFS=$'\n\t' + +positional_args=() +while [[ "$#" -gt 0 ]]; do + arg="${1}" + case "${arg}" in + -h|--help) + print_usage + exit 0 + ;; + *) + positional_args+=("$1") + shift + ;; + esac +done + +original_name=${positional_args[0]:-} +if [[ -z ${original_name} ]]; then + echo "error: missing original tarball name" + exit 1 +fi + +new_name=${positional_args[1]:-} +if [[ -z ${new_name} ]]; then + echo "error: missing new tarball name" + exit 1 +fi + +original_name=${original_name/%.tar.gz} +new_name=${new_name/.tar.gz} + +echo "Original: ${original_name}.tar.gz" +echo "New name: ${new_name}.tar.gz" + +mkdir "temp-${new_name}" +pushd "temp-${new_name}" +tar xf "../${original_name}.tar.gz" +mv "${original_name}" "${new_name}" +tar czf ../"${new_name}.tar.gz" "${new_name}" +rm -rf "${new_name}" +popd +rmdir "temp-${new_name}" diff --git a/runtime-47020-gcc11.patch b/runtime-47020-gcc11.patch new file mode 100644 index 0000000..3751fcf --- /dev/null +++ b/runtime-47020-gcc11.patch @@ -0,0 +1,55 @@ +From 7123b8344ddc1c883483f13d34abbd22d4170452 Mon Sep 17 00:00:00 2001 +From: Omair Majid +Date: Tue, 5 Jan 2021 18:50:18 -0500 +Subject: [PATCH] Fix build errors using GCC 11 (#46334) + +Building runtime with GCC 11 leads to some new errors. The errors are +consistent with the "Header dependency changes" section documented at +https://gcc.gnu.org/gcc-11/porting_to.html + +The first set of errors looks like this: + + runtime/src/coreclr/pal/src/misc/cgroup.cpp:403:29: + error: no member named 'numeric_limits' in namespace 'std' + if (temp > std::numeric_limits::max()) + ~~~~~^ + +Fix that by including . + +The second set of errors looks like this: + + runtime/src/installer/corehost/cli/test/nativehost/host_context_test.cpp:634:31: + error: no member named 'sleep_for' in namespace 'std::this_thread' + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + ~~~~~~~~~~~~~~~~~~^ + +Fix that by including . +--- + src/coreclr/src/pal/src/misc/cgroup.cpp | 1 + + src/installer/corehost/cli/test/nativehost/host_context_test.cpp | 1 + + 2 files changed, 2 insertions(+) + +diff --git a/src/coreclr/src/pal/src/misc/cgroup.cpp b/src/coreclr/src/pal/src/misc/cgroup.cpp +index f3e20012c539..24617359a21b 100644 +--- a/src/coreclr/src/pal/src/misc/cgroup.cpp ++++ b/src/coreclr/src/pal/src/misc/cgroup.cpp +@@ -14,6 +14,7 @@ Module Name: + #include "pal/dbgmsg.h" + SET_DEFAULT_DEBUG_CHANNEL(MISC); + #include "pal/palinternal.h" ++#include + #include + #include + #include "pal/virtual.h" +diff --git a/src/installer/corehost/cli/test/nativehost/host_context_test.cpp b/src/installer/corehost/cli/test/nativehost/host_context_test.cpp +index cea98db6673a..371ec2d7e2aa 100644 +--- a/src/installer/corehost/cli/test/nativehost/host_context_test.cpp ++++ b/src/installer/corehost/cli/test/nativehost/host_context_test.cpp +@@ -11,6 +11,7 @@ + #include + #include "hostfxr_exports.h" + #include "host_context_test.h" ++#include + #include + + namespace diff --git a/runtime-linker-order.patch b/runtime-linker-order.patch new file mode 100644 index 0000000..6ca413f --- /dev/null +++ b/runtime-linker-order.patch @@ -0,0 +1,20 @@ +diff --git a/src/installer/corehost/cli/apphost/static/CMakeLists.txt b/src/installer/corehost/cli/apphost/static/CMakeLists.txt +index 85ea6ffe642..e6369f6b9ad 100644 +--- a/src/installer/corehost/cli/apphost/static/CMakeLists.txt ++++ b/src/installer/corehost/cli/apphost/static/CMakeLists.txt +@@ -204,11 +204,12 @@ target_link_libraries(singlefilehost + libhostcommon + ${CORECLR_LIBRARIES} + ++ ${START_WHOLE_ARCHIVE} ++ ${NATIVE_LIBS} ++ ${END_WHOLE_ARCHIVE} ++ + ${ZLIB_LIBRARIES} + ${LIBGSS} + ${NATIVE_LIBS_EXTRA} + +- ${START_WHOLE_ARCHIVE} +- ${NATIVE_LIBS} +- ${END_WHOLE_ARCHIVE} + ) diff --git a/sdk-telemetry-optout.patch b/sdk-telemetry-optout.patch new file mode 100644 index 0000000..9b92f33 --- /dev/null +++ b/sdk-telemetry-optout.patch @@ -0,0 +1,18 @@ +diff --git a/src/Cli/dotnet/Program.cs b/src/Cli/dotnet/Program.cs +index de1ebb9e6..6bbf479de 100644 +--- a/src/Cli/dotnet/Program.cs ++++ b/src/Cli/dotnet/Program.cs +@@ -28,6 +28,13 @@ public class Program + + public static int Main(string[] args) + { ++ // opt out of telemetry by default if the env var is unset ++ string telemetryValue = Environment.GetEnvironmentVariable("DOTNET_CLI_TELEMETRY_OPTOUT"); ++ if (String.IsNullOrEmpty(telemetryValue)) ++ { ++ Environment.SetEnvironmentVariable("DOTNET_CLI_TELEMETRY_OPTOUT", "1"); ++ } ++ + DebugHelper.HandleDebugSwitch(ref args); + + new MulticoreJitActivator().TryActivateMulticoreJit(); diff --git a/source-build-runtime-fixup-linker-order.patch b/source-build-runtime-fixup-linker-order.patch new file mode 100644 index 0000000..5a74b5d --- /dev/null +++ b/source-build-runtime-fixup-linker-order.patch @@ -0,0 +1,13 @@ +--- a/patches/runtime/0014-Fix-singlefilehost-build-in-non-portable-mode-42415.patch ++++ b/patches/runtime/0014-Fix-singlefilehost-build-in-non-portable-mode-42415.patch +@@ -45,8 +45,8 @@ + # These options are used to force every object to be included even if it's unused. + set(START_WHOLE_ARCHIVE -Wl,--whole-archive) + @@ -212,3 +217,10 @@ target_link_libraries(singlefilehost +- ${NATIVE_LIBS} +- ${END_WHOLE_ARCHIVE} ++ ${NATIVE_LIBS_EXTRA} ++ + ) + + + +if(NOT FEATURE_DISTRO_AGNOSTIC_SSL) diff --git a/tests/.fmf/version b/tests/.fmf/version new file mode 100644 index 0000000..0cfbf08 --- /dev/null +++ b/tests/.fmf/version @@ -0,0 +1 @@ +2 diff --git a/tests/provision.fmf b/tests/provision.fmf new file mode 100644 index 0000000..87b3807 --- /dev/null +++ b/tests/provision.fmf @@ -0,0 +1,6 @@ +--- + +standard-inventory-qcow2: + qemu: + m: 5G + diff --git a/tests/tests.yml b/tests/tests.yml new file mode 100644 index 0000000..d63f183 --- /dev/null +++ b/tests/tests.yml @@ -0,0 +1,35 @@ +--- +- hosts: localhost + roles: + - role: standard-test-basic + tags: + - classic + - container + - atomic + repositories: + - repo: "https://github.com/redhat-developer/dotnet-regular-tests.git" + dest: "dotnet-regular-tests" + version: main + tests: + - download_test_runner: + dir: ./ + run: wget --no-verbose https://github.com/redhat-developer/dotnet-bunny/releases/latest/download/turkey-$(uname -m) -O turkey && chmod +x ./turkey + - print_test_runner_version: + dir: ./ + run: ./turkey --version + - regular: + dir: ./ + run: ./turkey -l={{ remote_artifacts }} dotnet-regular-tests + required_packages: + - babeltrace + - bash-completion + - binutils + - expect + - jq + - lldb + - lttng-tools + - npm + - python3 + - strace + - wget + - which diff --git a/update-release b/update-release new file mode 100755 index 0000000..da87262 --- /dev/null +++ b/update-release @@ -0,0 +1,63 @@ +#!/bin/bash + +# Usage: +# ./update-release sdk-version runtime-version + +set -euo pipefail +IFS=$'\n\t' + +print_usage() { + echo " Usage:" + echo " ./update-release sdk-version runtime-version" +} + +positional_args=() +while [[ "$#" -gt 0 ]]; do + arg="${1}" + case "${arg}" in + -h|--help) + print_usage + exit 0 + ;; + *) + positional_args+=("$1") + shift + ;; + esac +done + +spec_file=dotnet5.0.spec + +sdk_version=${positional_args[0]:-} +if [[ -z ${sdk_version} ]]; then + echo "error: missing sdk version" + exit 1 +fi + +runtime_version=${positional_args[1]:-} +if [[ -z ${runtime_version} ]]; then + echo "error: missing runtime version" + exit 1 +fi + +host_version="$runtime_version" + +if [[ ! -f "dotnet-v${sdk_version}-SDK.tar.gz" ]]; then + ./build-dotnet-tarball "v${sdk_version}-SDK" +fi + +set -x + +sed -i -E "s|^%global host_version [[:digit:]]\.[[:digit:]]\.[[:digit:]]+|%global host_version ${host_version}|" "$spec_file" +sed -i -E "s|^%global runtime_version [[:digit:]]\.[[:digit:]]\.[[:digit:]]+|%global runtime_version ${runtime_version}|" "$spec_file" +sed -i -E "s|^%global sdk_version [[:digit:]]\.[[:digit:]]\.[[:digit:]][[:digit:]][[:digit:]]|%global sdk_version ${sdk_version}|" "$spec_file" + +comment="Update to .NET Core Runtime ${runtime_version} and SDK ${sdk_version}" + +rpmdev-bumpspec --comment="$comment" $spec_file + +# Reset release to 1 in 'Release' tag +sed -i -E 's|^Release: [[:digit:]]+%|Release: 1%|' $spec_file +# Reset Release in changelog comment +# See https://stackoverflow.com/questions/18620153/find-matching-text-and-replace-next-line +sed -i -E '/^%changelog$/!b;n;s/-[[:digit:]]+$/-1/' $spec_file