System.ComponentModel.Composition, System.Diagnostics.PerformanceCounter and System.Runtime.Caching.

Helps with https://github.com/dotnet/runtime/issues/54012

* Implement ServiceController.Stop(bool) overload with test

* Add basic docs for new ServiceController.Stop overload

* Name boolean parameter
Co-authored-by: NIlya <darpa@yandex.ru>

* Add a test for a valid use of ServiceController.Stop(bool)

* Run tests for the new Stop(bool) overload only on .NETCoreApp

* Add a test for manually stopping a service and its dependents with Stop(false)

* Expose new Stop(bool) overload only for .NET Core 3.1+

* Target netcoreapp3.1
Co-authored-by: NIlya <darpa@yandex.ru>
Co-authored-by: NViktor Hofer <viktor.hofer@microsoft.com>

This lock existed to protect HttpClient.DefaultRequestHeaders.  While headers collections aren't meant to be thread-safe, out of necessity the design of DefaultRequestHeaders required this lock be in place, with multiple concurrent requests all potentially enumerating DefaultRequestHeaders in order to copy its contents into the outgoing request.  Such enumeration could trigger parsing, which could trigger the same object to be mutated from multiple threads to store the parsed result.  But as of https://github.com/dotnet/runtime/pull/49673, we no longer force parsing of the DefaultRequestHeaders, instead preferring to just transfer everything over as-is.  With that, there shouldn't be any concurrent mutation of these objects (and if there is, it's user error doing their own concurrent enumeration of a header collection).

* Fix NTLM authentication from macOS to Windows machines

The GSSAPI implementation on macOS has partially broken NTLM implementation. It only supports NTLMv2 with the message integrity code (MIC) as specified by the MS-NLMP specification. The MIC is calculated using HMAC-MD5 authentication code over the exchanged NTLM messages with a key named ExportedSessionKey. The proper generation of ExportedSessionKey requires the implementation to negotiate correct capabilities, namely NTLMSSP_NEGOTIATE_KEY_EXCH and at least one of NTLMSSP_NEGOTIATE_SIGN or NTLMSSP_NEGOTIATE_SEAL flags. By default the macOS implementation negotiates NTLMSSP_NEGOTIATE_KEY_EXCH and sends MIC but fails to set one of the additional flags that would make the key exchange valid. This results in violation of the following part of the NTLM specification:

"A session key MUST always exist to generate the MIC (section 3.1.5.1.2) in the authenticate message. NTLMSSP_NEGOTIATE_ALWAYS_SIGN MUST be set in the NEGOTIATE_MESSAGE to the server and the CHALLENGE_MESSAGE to the client."

Adding the GSS_C_INTEG_FLAG flag forces macOS to properly negitiate all the necessary flags (NTLMSSP_NEGOTIATE_ALWAYS_SIGN and NTLMSSP_NEGOTIATE_SIGN) to make the MIC exchange valid. This in turn enables the whole NTLM exchange to be recognized as valid by Windows server side.

The gss-ntlmssp package on Linux interprets the GSS_C_INTEG_FLAG flag as additional negotiation of NTLMSSP_NEGOTIATE_SIGN and NTLMSSP_NEGOTIATE_KEY_EXCH. That should not hurt anything and in fact it may improve security depending on specific configuration. The flag was already specified when NTLM was used by System.Net.Mail.SmtpClient.

* Add temporary test to verify NTLM and Negotiate connections from all platforms

Notably this is expected to fail on Android and tvOS where GSSAPI is not available.

The test machine is single purpose virtual machine running in Azure with clean Windows Server 2019 installation and all the patches. It hosts IIS with single static page behind an NT authentication. The test account and the machine itself is disposable and does NOT contain any sensitive data. Nevertheless I don't expect this test to be merged.

* Use full domain name in test credentials

* Revert "Use full domain name in test credentials"

This reverts commit ea4dc615824c207845628143addc7d8c774ce702.

* Revert "Add temporary test to verify NTLM and Negotiate connections from all platforms"

This reverts commit abf44ce1430edf631fe74b15d354eca9073b4c83.

* Set the async local just before execution.
- Subscribing to DiagnosticListener.AllListeners replays all created DiagnosticListener instances. Because of this, we need to set the async local just before the execution of the entry point so that we only collect the events that are relevant to the call. Right now, it's also firing with the async local set pre-maturely.
- Wrote a concurrency test to make sure it's safe to instantiate the factory in parallel.

Use the non-Emit codepath if IsDynamicCodeSupported is false.

* Cleanup BitVector32

* Cleanup Section.ToString

* [MacCatalyst][libraries] Skip Crashing test suites

* Fix typos

* Add System.Linq.Parallel skip AppCrash

* Add Amore arm64 flakes

* Add additional App Launch Failure skip

* Add System.IO.UnmanagedMemoryStream.Tests skip

* Add more tests failing to app launch failures
Co-authored-by: NMitchell Hwang <mitchell.hwang@microsoft.com>

Assuming that GetAddressBytes() does not have side effects, this call
should not be needed.

Clean up from dotnet/runtime#53461

* Add dependency on coreclr in monojit/monointerpreter jobs explicitly to solve pipeline issue #53842
* Use Helix Pre/Post hooks to kill linkering corerun instances to work around ARM64 agent issues
Co-authored-by: NKunal Pathak <Kunal.Pathak@microsoft.com>

* Scope events to the execution of the entry point
- Today we're using the global event source and events that fire in the app domain get captured and this can result in capturing the wrong instances. This fix uses an async local to scope the events for the HostingEventListener to the execution of the application's entry point.
- Removed the RemoteExecutor as a result of this change
- Remove RequirementsMet property

* Add support for IServiceProviderIsService
- This optional service lets consumers query to see if a service is resolvable without side effects (not having to explicitly resolve the service).
- Added new spec tests to verify the baseline behavior based on IServiceCollection features.
- Handle built in services as part of IsServce
- Special case built in services as part of the IsService check
- Make the tests part of the core DI tests and enable skipping via a property
Co-authored-by: NTravis Illig <tillig@paraesthesia.com>

Co-authored-by: NLarry Ewing <lewing@microsoft.com>

Stream.Read{Async} is supposed to return once at least a byte of data is available, and in particular, if there's any data already available, it shouldn't block.  But Read{Async} on DeflateStream (and thus also GZipStream and ZLibStream), BrotliStream, and CryptoStream won't return until either it hits the end of the stream or the caller's buffer is filled.  This makes it behave very unexpectedly when used in a context where the app is using a large read buffer but expects to be able to process data as it's available, e.g. in networked streaming scenarios where messages are being sent as part of bidirectional communication.

This fixes that by stopping looping once any data is consumed.  Just doing that, though, caused problems for zero-byte reads.  Zero-byte reads are typically used by code that's trying to delay-allocate a buffer for the read data until data will be available to read.  At present, however, zero-byte reads return immediately regardless of whether data is available to be consumed.  I've changed the flow to make it so that zero-byte reads don't return until there's at least some data available as input to the inflater/transform (this, though, doesn't 100% guarantee the inflater/transform will be able to produce output data).

Note that both of these changes have the potential to introduce breaks into an app that erroneously depended on these implementation details:
- If an app passing in a buffer of size N to Read{Async} depended on that call always producing the requested number of bytes (rather than what the Stream contract defines), they might experience behavioral changes.
- If an app passing in a zero-byte buffer expected it to return immediately, it might instead end up waiting until data was actually available.

* 32bit

* 64bit

* Expose in public api

* Unit test

* Add more tests

* Use in test

* Apply suggestions from code review
Co-authored-by: NStephen Toub <stoub@microsoft.com>
Co-authored-by: NStephen Toub <stoub@microsoft.com>

* make MsQuicStatusCodes platform specific

* add missing StreamLimit

* Re-enabled mock tests for H/3.

* Used IsMockQuicSupported to run the mock tests only on supported platforms.

* Disabling mock test completely.

* Hanging test fix experiment.

* Disabled some mock tests failing in CI.

* Vector.Sum(Vector<T>) API implementation for horizontal add.

* Fixed inccorrect referece to Arm64 AddAccross intrinsic function.

* Added implementation for hardware accelerated Vector<T>.Sum for long, ulong, float, double on ARM64.

* Fixed formatting issue.

* Correctness.

* Fixed compiler error for ARM64.

* Formatting issue.

* More explicit switch statement. Fixed wrong simd size for NI_Vector64_ToScalar.

* Fixed auto formatting issue.

* Use AddPairwiseScalar for double, long and ulong on ARM64 for VectorT128_Sum.

* Forgot ToScalar call after AddPairwiseScalar.

* Fixed wrong return type.

- Cleaned up the comments to explain what ResolveHostFactory does.
- Added entry point completed callback to let callers know when the entry point code is done running.
- Added tests for the various callbacks.

* Fix #53632

* Annotate non-nullable _originAuthority

* Test inheriting original host for HTTP/3 Alt-Svc

* Make some Brotli p/invokes blittable

* Use Interop.BOOL

Add trimmer annotations to System.Data.Common
Co-authored-by: NEric Erhardt <eric.erhardt@microsoft.com>

* [wasm][aot] Enable tests that are passing now

These don't reproduce on `main` anymore, after the exceptions fix.

`System.Transactions.Locals.Tests` Fixes https://github.com/dotnet/runtime/issues/50969
`System.Threading.Tasks.Parallel.Tests` Fixes https://github.com/dotnet/runtime/issues/51677

* [wasm][aot][tests] Enable `System.Xml.Xsl.XslCompiledTransformApi.Tests`

This hasn't been crashing for quite some time.
The individual test failures are already disabled with
https://github.com/dotnet/runtime/issues/51244, and
https://github.com/dotnet/runtime/issues/51911 .

Fixes https://github.com/dotnet/runtime/issues/51245

* improve HttpClientHandler_Http11_Cancellation_Test and rename to SocketsHttpHandler_Http11_Cancellation_Test
Co-authored-by: NGeoffrey Kizer <geoffrek@windows.microsoft.com>

* Don't reference ns.dll inside shared framework

The netstandard.dll shim shouldn't be referenced inside the shared
framework as it's a compat shim that shouldn't be required to compose
the shared framework.

This removes the necessity of a separate RefPath build and improves
incremental build times as only the few OOB projects that require the
shim would need to rebuild.

* Reference netstandard shim in OOBs that require it

There are a few OOB projects that require the netstandard.dll shim as
they intentionally reference projects that only expose a netstandard
configuration.
Co-authored-by: NBuyaa Namnan <buyankhishig.namnan@microsoft.com>

* Make the ZLib P/Invokes all blittable

The only time {U}Int{32/64}.TryParse needs to consult a culture is if it needs to look up the negative symbol from it, and if NumberStyles.None or NumberStyles.HexNumber are passed, it won't ever do that.  All such call sites benefit from using CultureInfo.InvariantCulture explicitly, as it's just a static field read, whereas passing in null causes the implementation to access CultureInfo.CurrentCulture, which incurs a thread-static read.  Most of our usage already does this, but a few sites don't; this fixes those.

* Fix Sysctl() in buffer size autodetection mode

The code private static unsafe void Sysct() in the
Interop/BSD/System.Native/Interop.Sysctl.cs has two flaws in the case
value == null && len == 0.

First, in case of failure, this code doesn't call FreeHGlobal() on the memory it
allocated right before. I.e., we have pure memory leak.

Second, the "I don't know how much memory is needed, please allocated it by
yourself" idea standing behind value == null && len == 0 assumes the Sysctl()
itself being responsible to avoid ENOMEM condition. It could happen when, for
example, we ask to list all processes in the system: this list could be expanded
between first and second actual sysctl() calls, making the second call fail. So
instead of a single try, we should try to allocate a bit more memory and try
again; not force all our callers to do this themselves, by catching
InvalidOperationException and analyzing it.

Fixes #52823

* add missing IntPtr <-> int casts

avoid using crypto in WASM unit tests so that we could cover more scenarios

* Set SupportedOSPlatforms at assembly level

Update build props to set SupportedOSPlatforms to windows assembly wide

* keep MsQuicConnection alive when streams are pending

* remove extra file

* fix gchandle

* feedback from review

* feedback from review

* feedback from review

It seems to hang for some reason.

https://github.com/dotnet/runtime/issues/53987