//
// This version of an Ssl Stream is for internal HttpWebrequest use.
// This Ssl client owns the underlined socket
// The TlsStream will own secured read/write and disposal of the passed "networkStream" stream.
//
public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext)
: base(networkStream, true)
{
// WebRequest manages the execution context manually so we have to ensure we get one for SSL client certificate demand
_ExecutionContext = executionContext;
if (_ExecutionContext == null)
{
_ExecutionContext = ExecutionContext.Capture();
}
//
GlobalLog.Enter("TlsStream::TlsStream", "host=" + destinationHost + ", #certs=" + ((clientCertificates == null) ? "none" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, this, ".ctor", "host=" + destinationHost + ", #certs=" + ((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));
}
m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure;
m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy);
m_DestinationHost = destinationHost;
m_ClientCertificates = clientCertificates;
RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest);
m_Worker.SetCertValidationDelegate(certValidationCallback);
// The Handshake is NOT done at this point
GlobalLog.Leave("TlsStream::TlsStream (Handshake is not done)");
}
private static void GetRequestStreamCallback(object state)
{
GlobalLog.Enter("FileWebRequest::GetRequestStreamCallback");
LazyAsyncResult asyncResult = (LazyAsyncResult)state;
FileWebRequest request = (FileWebRequest)asyncResult.AsyncObject;
try
{
if (request.m_stream == null)
{
request.m_stream = new FileWebStream(request, request.m_uri.LocalPath, FileMode.Create, FileAccess.Write, FileShare.Read);
request.m_fileAccess = FileAccess.Write;
request.m_writing = true;
}
}
catch (Exception e)
{
// any exceptions previously thrown must be passed to the callback
Exception ex = new WebException(e.Message, e);
GlobalLog.LeaveException("FileWebRequest::GetRequestStreamCallback", ex);
// if the callback throws, correct behavior is to crash the process
asyncResult.InvokeCallback(ex);
return;
}
// if the callback throws, correct behavior is to crash the process
asyncResult.InvokeCallback(request.m_stream);
GlobalLog.Leave("FileWebRequest::GetRequestStreamCallback");
}
internal static byte[] EncodingRightGetBytes(string rawString)
{
GlobalLog.Enter("BasicClient::EncodingRightGetBytes", "[" + rawString.Length.ToString() + ":" + rawString + "]");
//
// in order to know if there will not be any '?' translations (which means
// we should use the Default Encoding) we need to attempt encoding and then decoding.
//
GlobalLog.Print("BasicClient::EncodingRightGetBytes(): Default Encoding is:" + Encoding.Default.EncodingName);
byte[] bytes = Encoding.Default.GetBytes(rawString);
string rawCopy = Encoding.Default.GetString(bytes);
bool canMapToCurrentCodePage = string.Compare(rawString, rawCopy, false, CultureInfo.InvariantCulture) == 0;
GlobalLog.Print("BasicClient::EncodingRightGetBytes(): canMapToCurrentCodePage:" + canMapToCurrentCodePage.ToString());
if (!canMapToCurrentCodePage)
{
throw ExceptionHelper.MethodNotSupportedException;
/*
* GlobalLog.Print("BasicClient::EncodingRightGetBytes(): using:" + Encoding.UTF8.EncodingName);
* bytes = Encoding.UTF8.GetBytes(rawString);
*
* string blob = "=?utf-8?B?" + Convert.ToBase64String(bytes) + "?=";
* bytes = Encoding.ASCII.GetBytes(blob);
*/
}
GlobalLog.Dump(bytes);
GlobalLog.Leave("BasicClient::EncodingRightGetBytes", bytes.Length.ToString());
return(bytes);
}
void ICloseEx.CloseEx(CloseExState closeState)
{
GlobalLog.Enter("FileWebResponse::Close()");
try {
if (!m_closed)
{
m_closed = true;
Stream chkStream = m_stream;
if (chkStream != null)
{
if (chkStream is ICloseEx)
{
((ICloseEx)chkStream).CloseEx(closeState);
}
else
{
chkStream.Close();
}
m_stream = null;
}
}
}
finally {
GlobalLog.Leave("FileWebResponse::Close()");
}
}
public override WebResponse GetResponse()
{
GlobalLog.Enter("FileWebRequest::GetResponse");
m_syncHint = true;
IAsyncResult result;
try {
result = BeginGetResponse(null, null);
if ((Timeout != System.Threading.Timeout.Infinite) && !result.IsCompleted)
{
if (!result.AsyncWaitHandle.WaitOne(Timeout, false) || !result.IsCompleted)
{
if (m_response != null)
{
m_response.Close();
}
Exception e = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.Timeout), WebExceptionStatus.Timeout);
GlobalLog.LeaveException("FileWebRequest::GetResponse", e);
throw e;
}
}
} catch (Exception exception) {
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "GetResponse", exception);
}
throw;
} finally {
GlobalLog.Leave("FileWebRequest::GetResponse");
}
return(EndGetResponse(result));
}
private static uint Verify(SafeX509ChainHandle chainContext, ref Interop.Crypt32.CERT_CHAIN_POLICY_PARA cpp)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Enter("SecureChannel::VerifyChainPolicy", "chainContext=" + chainContext + ", options=" + String.Format("0x{0:x}", cpp.dwFlags));
}
var status = new Interop.Crypt32.CERT_CHAIN_POLICY_STATUS();
status.cbSize = (uint)Marshal.SizeOf <Interop.Crypt32.CERT_CHAIN_POLICY_STATUS>();
bool errorCode =
Interop.Crypt32.CertVerifyCertificateChainPolicy(
(IntPtr)Interop.Crypt32.CertChainPolicy.CERT_CHAIN_POLICY_SSL,
chainContext,
ref cpp,
ref status);
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("SecureChannel::VerifyChainPolicy() CertVerifyCertificateChainPolicy returned: " + errorCode);
#if TRACE_VERBOSE
GlobalLog.Print("SecureChannel::VerifyChainPolicy() error code: " + status.dwError + String.Format(" [0x{0:x8}", status.dwError) + " " + Interop.MapSecurityStatus(status.dwError) + "]");
#endif
GlobalLog.Leave("SecureChannel::VerifyChainPolicy", status.dwError.ToString());
}
return(status.dwError);
}
//
// this method runs in the context of the user Begin call .
//
private static void WrappedGetRequestStreamCallback(object state)
{
GlobalLog.Enter("FileWebRequest::GetRequestStreamCallback");
ContextAwareResult asyncResult = (ContextAwareResult)state;
FileWebRequest request = (FileWebRequest)asyncResult.AsyncObject;
try
{
if (request.m_stream == null)
{
request.m_stream = new FileWebStream(request, request.m_uri.LocalPath, FileMode.Create, FileAccess.Write, FileShare.Read);
request.m_fileAccess = FileAccess.Write;
request.m_writing = true;
asyncResult.InvokeCallback(request.m_stream);
GlobalLog.Leave("FileWebRequest::GetRequestStreamCallback");
}
}
catch (Exception e)
{
if (asyncResult.IsCompleted || NclUtilities.IsFatal(e))
{
throw;
}
Exception ex = new WebException(e.Message, e);
GlobalLog.LeaveException("FileWebRequest::GetRequestStreamCallback", ex);
asyncResult.InvokeCallback(ex);
}
}
public override WebResponse EndGetResponse(IAsyncResult asyncResult)
{
GlobalLog.Enter("FileWebRequest::EndGetResponse");
WebResponse response;
try {
ContextAwareResult ar = asyncResult as ContextAwareResult;
if (asyncResult == null || ar == null)
{
Exception e = asyncResult == null? new ArgumentNullException("asyncResult"): new ArgumentException(SR.GetString(SR.InvalidAsyncResult), "asyncResult");
GlobalLog.LeaveException("FileWebRequest::EndGetRequestStream", e);
throw e;
}
object result = ar.InternalWaitForCompletion();
if (result is Exception)
{
throw (Exception)result;
}
response = (WebResponse)result;
m_readPending = false;
} catch (Exception exception) {
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "EndGetResponse", exception);
}
throw;
} finally {
GlobalLog.Leave("FileWebRequest::EndGetResponse");
}
return(response);
}
/// <include file='doc\filewebresponse.uex' path='docs/doc[@for="FileWebResponse.GetResponseStream"]/*' />
public override Stream GetResponseStream()
{
GlobalLog.Enter("FileWebResponse::GetResponseStream()");
CheckDisposed();
GlobalLog.Leave("FileWebResponse::GetResponseStream()");
return(m_stream);
}
/// <devdoc>
/// <para>Creates a new PooledStream is allowable</para>
/// </devdoc>
private PooledStream UserCreateRequest()
{
// called by user when they were not able to obtain a free object but
// instead obtained creation mutex
GlobalLog.Enter("ConnectionPool#" + ValidationHelper.HashString(this) + "::UserCreateRequest");
PooledStream pooledStream = null;
if (!ErrorOccurred)
{
if (Count < MaxPoolSize || 0 == MaxPoolSize)
{
// If we have an odd number of total objects, reclaim any dead objects.
// If we did not find any objects to reclaim, create a new one.
//
if ((Count & 0x1) == 0x1 || !ReclaimEmancipatedObjects())
{
pooledStream = Create(m_CreateConnectionCallback);
}
}
}
GlobalLog.Leave("ConnectionPool#" + ValidationHelper.HashString(this) + "::UserCreateRequest", ValidationHelper.HashString(pooledStream));
return(pooledStream);
}
public static SafeFreeContextBufferChannelBinding QueryContextChannelBinding(SSPIInterface secModule, SafeDeleteContext securityContext, Interop.SspiCli.ContextAttribute contextAttribute)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Enter(nameof(QueryContextChannelBinding), contextAttribute.ToString());
}
SafeFreeContextBufferChannelBinding result;
int errorCode = secModule.QueryContextChannelBinding(securityContext, contextAttribute, out result);
if (errorCode != 0)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Leave(nameof(QueryContextChannelBinding), "ERROR = " + ErrorDescription(errorCode));
}
return(null);
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Leave(nameof(QueryContextChannelBinding), LoggingHash.HashString(result));
}
return(result);
}
//
// SetTcpKeepAlive
//
// Enable/Disable the use of TCP keepalive option on ServicePoint
// connections. This method does not affect existing ServicePoints.
// When a ServicePoint is constructed it will inherit the current
// settings.
//
// Parameters:
//
// enabled - if true enables the use of the TCP keepalive option
// for ServicePoint connections.
//
// keepAliveTime - specifies the timeout, in milliseconds, with no
// activity until the first keep-alive packet is sent. Ignored if
// enabled parameter is false.
//
// keepAliveInterval - specifies the interval, in milliseconds, between
// when successive keep-alive packets are sent if no acknowledgement is
// received. Ignored if enabled parameter is false.
//
public static void SetTcpKeepAlive(
bool enabled,
int keepAliveTime,
int keepAliveInterval)
{
GlobalLog.Enter(
"ServicePointManager::SetTcpKeepAlive()" +
" enabled: " + enabled.ToString() +
" keepAliveTime: " + keepAliveTime.ToString() +
" keepAliveInterval: " + keepAliveInterval.ToString()
);
if (enabled)
{
s_UseTcpKeepAlive = true;
if (keepAliveTime <= 0)
{
throw new ArgumentOutOfRangeException("keepAliveTime");
}
if (keepAliveInterval <= 0)
{
throw new ArgumentOutOfRangeException("keepAliveInterval");
}
s_TcpKeepAliveTime = keepAliveTime;
s_TcpKeepAliveInterval = keepAliveInterval;
}
else
{
s_UseTcpKeepAlive = false;
s_TcpKeepAliveTime = 0;
s_TcpKeepAliveInterval = 0;
}
GlobalLog.Leave("ServicePointManager::SetTcpKeepAlive()");
}
internal HttpProxyTunnelRequest(Uri proxyUri, Uri requestUri) : base(proxyUri)
{
GlobalLog.Enter("HttpProxyTunnelRequest::HttpProxyTunnelRequest",
"proxyUri=" + proxyUri + ", requestUri=" + requestUri
);
Method = "CONNECT";
//
// CONNECT requests cannot be pipelined
//
Pipelined = false;
m_originServer = requestUri;
//
// each CONNECT request has a unique connection group name to avoid
// non-CONNECT requests being made over the same connection
//
ConnectionGroupName = ServicePointManager.SpecialConnectGroupName + "(" + UniqueGroupId + ")";
//
// the CONNECT request must respond to a 407 as if it were a 401.
// So we set up the server authentication state as if for a proxy
//
ServerAuthenticationState = new AuthenticationState(true);
GlobalLog.Leave("HttpProxyTunnelRequest::HttpProxyTunnelRequest");
}
public FileWebStream(FileWebRequest request, string path, FileMode mode, FileAccess access, FileShare sharing, int length, bool async)
: base(path, mode, access, sharing, length, async)
{
GlobalLog.Enter("FileWebStream::FileWebStream");
m_request = request;
GlobalLog.Leave("FileWebStream::FileWebStream");
}
//
// ScavengeIdleServicePoints -
//
// Removes an Idled ServicePoint as it is detected to be
// expired and ready to be removed. This is called fairly
// often, so we should be O(1) in the case when no service points
// have idled.
//
private static void ScavengeIdleServicePoints()
{
DateTime now = DateTime.Now;
GlobalLog.Enter("ServicePointManager::ScavengeIdleServicePoints() now:" + (now.ToFileTime()).ToString());
lock (s_StrongReferenceServicePointList) {
while (s_StrongReferenceServicePointList.Count != 0)
{
DateTime expiresAt = (DateTime)s_StrongReferenceServicePointList.GetKey(0);
if (ServicePoint.InternalTimedOut(now, expiresAt))
{
ServicePoint servicePoint = (ServicePoint)
s_StrongReferenceServicePointList.GetByIndex(0);
GlobalLog.Print("ServicePointManager::ScavengeIdleServicePoints() servicePoint#" + ValidationHelper.HashString(servicePoint) + " ExpiresAt:" + (servicePoint.ExpiresAt.ToFileTime()).ToString() + " is being removed");
s_StrongReferenceServicePointList.RemoveAt(0);
}
else
{
// if the first in the list isn't expired, than no one later is either
break;
}
}
}
GlobalLog.Leave("ServicePointManager::ScavengeIdleServicePoints");
}
//
// IDisposable
//
/// <include file='doc\filewebresponse.uex' path='docs/doc[@for="FileWebResponse.IDisposable.Dispose"]/*' />
/// <internalonly/>
void IDisposable.Dispose()
{
GlobalLog.Enter("FileWebResponse::Dispose");
Dispose(true);
GC.SuppressFinalize(this);
GlobalLog.Leave("FileWebResponse::Dispose");
}
// methods
/// <include file='doc\filewebrequest.uex' path='docs/doc[@for="FileWebRequest.BeginGetRequestStream"]/*' />
public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
{
GlobalLog.Enter("FileWebRequest::BeginGetRequestStream");
if (!CanGetRequestStream())
{
Exception e = new ProtocolViolationException(SR.GetString(SR.net_nouploadonget));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
if (m_response != null)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_reqsubmitted));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
lock (this) {
if (m_writePending)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
m_writePending = true;
}
m_GetRequestStreamDelegate = new AsyncGetRequestStream(InternalGetRequestStream);
GlobalLog.Leave("FileWebRequest::BeginGetRequestStream");
return(m_GetRequestStreamDelegate.BeginInvoke(callback, state));
}
public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
{
GlobalLog.Enter("FileWebRequest::BeginGetRequestStream");
try {
if (Aborted)
{
throw ExceptionHelper.RequestAbortedException;
}
if (!CanGetRequestStream())
{
Exception e = new ProtocolViolationException(SR.GetString(SR.net_nouploadonget));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
if (m_response != null)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_reqsubmitted));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
lock (this) {
if (m_writePending)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
m_writePending = true;
}
//we need to force the capture of the identity and context to make sure the
//posted callback doesn't inavertently gain access to something it shouldn't.
m_ReadAResult = new LazyAsyncResult(this, state, callback);
ThreadPool.QueueUserWorkItem(s_GetRequestStreamCallback, m_ReadAResult);
} catch (Exception exception) {
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "BeginGetRequestStream", exception);
}
throw;
} finally {
GlobalLog.Leave("FileWebRequest::BeginGetRequestSteam");
}
string suri;
if (FrameworkEventSource.Log.IsEnabled(EventLevel.Verbose, FrameworkEventSource.Keywords.NetClient))
{
suri = this.RequestUri.ToString();
}
else
{
suri = this.RequestUri.OriginalString;
}
FrameworkEventSource.Log.BeginGetRequestStream(this, suri);
return(m_ReadAResult);
}
internal static SecurityPackageInfoClass[] EnumerateSecurityPackages(SSPIInterface secModule)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Enter(nameof(EnumerateSecurityPackages));
}
if (secModule.SecurityPackages == null)
{
lock (secModule)
{
if (secModule.SecurityPackages == null)
{
int moduleCount = 0;
SafeFreeContextBuffer arrayBaseHandle = null;
try
{
int errorCode = secModule.EnumerateSecurityPackages(out moduleCount, out arrayBaseHandle);
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("SSPIWrapper::arrayBase: " + (arrayBaseHandle.DangerousGetHandle().ToString("x")));
}
if (errorCode != 0)
{
throw new Win32Exception(errorCode);
}
var securityPackages = new SecurityPackageInfoClass[moduleCount];
int i;
for (i = 0; i < moduleCount; i++)
{
securityPackages[i] = new SecurityPackageInfoClass(arrayBaseHandle, i);
if (SecurityEventSource.Log.IsEnabled())
{
SecurityEventSource.Log.EnumerateSecurityPackages(securityPackages[i].Name);
}
}
secModule.SecurityPackages = securityPackages;
}
finally
{
if (arrayBaseHandle != null)
{
arrayBaseHandle.Dispose();
}
}
}
}
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Leave(nameof(EnumerateSecurityPackages));
}
return(secModule.SecurityPackages);
}
public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
{
GlobalLog.Enter("FileWebRequest::BeginGetRequestStream");
#if !MONO
bool success = true;
#endif
try {
if (Aborted)
{
throw ExceptionHelper.RequestAbortedException;
}
if (!CanGetRequestStream())
{
Exception e = new ProtocolViolationException(SR.GetString(SR.net_nouploadonget));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
if (m_response != null)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_reqsubmitted));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
lock (this) {
if (m_writePending)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
m_writePending = true;
}
//we need to force the capture of the identity and context to make sure the
//posted callback doesn't inavertently gain access to something it shouldn't.
m_ReadAResult = new LazyAsyncResult(this, state, callback);
ThreadPool.QueueUserWorkItem(s_GetRequestStreamCallback, m_ReadAResult);
} catch (Exception exception) {
#if !MONO
success = false;
#endif
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "BeginGetRequestStream", exception);
}
throw;
} finally {
#if !MONO
if (FrameworkEventSource.Log.IsEnabled())
{
LogBeginGetRequestStream(success, synchronous: false);
}
#endif
GlobalLog.Leave("FileWebRequest::BeginGetRequestSteam");
}
return(m_ReadAResult);
}
protected override void BuildInternal()
{
GlobalLog.Enter("WinHttpWebProxyBuilder#" + ValidationHelper.HashString(this) + "::BuildInternal()");
UnsafeNclNativeMethods.WinHttp.WINHTTP_CURRENT_USER_IE_PROXY_CONFIG ieProxyConfig =
new UnsafeNclNativeMethods.WinHttp.WINHTTP_CURRENT_USER_IE_PROXY_CONFIG();
// Make sure the native strings get freed, even if some unexpected exception occurs.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (UnsafeNclNativeMethods.WinHttp.WinHttpGetIEProxyConfigForCurrentUser(ref ieProxyConfig))
{
string proxy = null;
string proxyByPass = null;
string autoConfigUrl = null;
proxy = Marshal.PtrToStringUni(ieProxyConfig.Proxy);
proxyByPass = Marshal.PtrToStringUni(ieProxyConfig.ProxyBypass);
autoConfigUrl = Marshal.PtrToStringUni(ieProxyConfig.AutoConfigUrl);
// note that ieProxyConfig.Proxy will be null if "use a proxy server" flag is turned off, even if
// the user specified a proxy address. When we read directly from the Registry we need to check
// for ProxyTypeFlags.PROXY_TYPE_PROXY. WinHttp does this for us and if the flag is not set,
// ieProxyConfig.Proxy will be null.
SetProxyAndBypassList(proxy, proxyByPass);
SetAutoDetectSettings(ieProxyConfig.AutoDetect);
// similar to comment above: ieProxyConfig.AutoConfigUrl will only be set if "automatically detect
// settings" flag is set. We don't need to check ProxyTypeFlags.PROXY_TYPE_AUTO_PROXY_URL; WinHttp
// takes care of it and sets AutoConfigUrl to null if the flag is not set, regardless of the actual
// config script string.
SetAutoProxyUrl(autoConfigUrl);
}
else
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == Microsoft.Win32.NativeMethods.ERROR_NOT_ENOUGH_MEMORY)
{
throw new OutOfMemoryException();
}
// if API call fails, rely on automatic detection
SetAutoDetectSettings(true);
}
}
finally
{
Marshal.FreeHGlobal(ieProxyConfig.Proxy);
Marshal.FreeHGlobal(ieProxyConfig.ProxyBypass);
Marshal.FreeHGlobal(ieProxyConfig.AutoConfigUrl);
}
GlobalLog.Leave("WinHttpWebProxyBuilder#" + ValidationHelper.HashString(this) + "::BuildInternal()");
}
public override void Close()
{
GlobalLog.Enter("FileWebStream::Close");
if (m_request != null)
{
m_request.UnblockReader();
}
base.Close();
GlobalLog.Leave("FileWebStream::Close");
}
private void EnumerateSecurityPackages()
{
GlobalLog.Enter("EnumerateSecurityPackages");
if (securityPackages == null)
{
lock (this)
{
if (securityPackages == null)
{
int moduleCount = 0;
SafeFreeContextBuffer arrayBaseHandle = null;
try
{
int errorCode = SafeFreeContextBuffer.EnumeratePackages(out moduleCount, out arrayBaseHandle);
GlobalLog.Print("SSPIWrapper::arrayBase: " + (arrayBaseHandle.DangerousGetHandle().ToString("x")));
if (errorCode != 0)
{
throw new Win32Exception(errorCode);
}
SecurityPackageInfoClass[] securityPackagesList = new SecurityPackageInfoClass[moduleCount];
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, SR.net_log_sspi_enumerating_security_packages);
}
for (int i = 0; i < moduleCount; i++)
{
securityPackagesList[i] = new SecurityPackageInfoClass(arrayBaseHandle, i);
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, " " + securityPackagesList[i].Name);
}
}
securityPackages = securityPackagesList;
}
finally
{
if (arrayBaseHandle != null)
{
arrayBaseHandle.Dispose();
}
}
}
}
}
GlobalLog.Leave("EnumerateSecurityPackages");
}
/// <devdoc>
/// <para>Places a new/reusable stream in the new stack of the pool</para>
/// </devdoc>
private void PutNew(PooledStream pooledStream)
{
GlobalLog.Enter("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutNew", "#" + ValidationHelper.HashString(pooledStream));
GlobalLog.Assert(null != pooledStream, "Why are we adding a null object to the pool?");
GlobalLog.Assert(pooledStream.CanBePooled, "Non-poolable object in pool.");
m_StackNew.Push(pooledStream);
Semaphore.ReleaseSemaphore();
GlobalLog.Leave("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutNew");
}
internal void UnblockReader()
{
GlobalLog.Enter("FileWebRequest::UnblockReader");
lock (this) {
if (m_readerEvent != null)
{
m_readerEvent.Set();
}
}
m_writing = false;
GlobalLog.Leave("FileWebRequest::UnblockReader");
}
public override void Abort()
{
GlobalLog.Enter("FileWebRequest::Abort");
if (Logging.On)
{
Logging.PrintWarning(Logging.Web, NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled));
}
try {
if (Interlocked.Increment(ref m_Aborted) == 1)
{
LazyAsyncResult readAResult = m_ReadAResult;
LazyAsyncResult writeAResult = m_WriteAResult;
WebException webException = new WebException(NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
Stream requestStream = m_stream;
if (readAResult != null && !readAResult.IsCompleted)
{
readAResult.InvokeCallback(webException);
}
if (writeAResult != null && !writeAResult.IsCompleted)
{
writeAResult.InvokeCallback(webException);
}
if (requestStream != null)
{
if (requestStream is ICloseEx)
{
((ICloseEx)requestStream).CloseEx(CloseExState.Abort);
}
else
{
requestStream.Close();
}
}
if (m_response != null)
{
((ICloseEx)m_response).CloseEx(CloseExState.Abort);
}
}
} catch (Exception exception) {
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "Abort", exception);
}
throw;
} finally {
GlobalLog.Leave("FileWebRequest::Abort");
}
}
/// <devdoc>
/// <para>Places a new/reusable stream in the new stack of the pool</para>
/// </devdoc>
private void PutNew(PooledStream pooledStream)
{
GlobalLog.Enter("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutNew", "#" + ValidationHelper.HashString(pooledStream));
GlobalLog.Assert(null != pooledStream, "Why are we adding a null object to the pool?");
GlobalLog.Assert(pooledStream.CanBePooled, "Non-poolable object in pool.");
m_StackNew.Push(pooledStream);
// ensure that the semaphore's count is incremented to signal an available connection is in
// the pool
Semaphore.ReleaseSemaphore();
GlobalLog.Leave("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutNew");
}
public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
{
GlobalLog.Enter("FileWebRequest::BeginGetRequestStream");
try {
if (Aborted)
{
throw ExceptionHelper.RequestAbortedException;
}
if (!CanGetRequestStream())
{
Exception e = new ProtocolViolationException(SR.GetString(SR.net_nouploadonget));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
if (m_response != null)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_reqsubmitted));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
lock (this) {
if (m_writePending)
{
Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
throw e;
}
m_writePending = true;
}
//we need to force the capture of the identity and context to make sure the
//posted callback doesn't inavertently gain access to something it shouldn't.
m_ReadAResult = new ContextAwareResult(true, true, true, this, state, callback);
lock (m_ReadAResult.StartPostingAsyncOp())
{
ThreadPool.UnsafeQueueUserWorkItem(s_GetRequestStreamCallback, m_ReadAResult);
m_ReadAResult.FinishPostingAsyncOp();
}
} catch (Exception exception) {
if (Logging.On)
{
Logging.Exception(Logging.Web, this, "BeginGetRequestStream", exception);
}
throw;
} finally {
GlobalLog.Leave("FileWebRequest::BeginGetRequestSteam");
}
return(m_ReadAResult);
}
private void AsyncReceiveComplete(IAsyncResult result)
{
GlobalLog.Enter("TlsStream#" + ValidationHelper.HashString(this) + "::AsyncReceiveComplete");
try {
int bytesRead = base.EndRead(result);
GlobalLog.Print("TlsStream#" + ValidationHelper.HashString(this) + "::AsyncReceiveComplete: received " + bytesRead + " bytes");
GlobalLog.Dump(m_AsyncResponseBuffer, bytesRead);
NextRecord(m_AsyncResponseBuffer, bytesRead);
} catch (Exception exception) {
InnerException = new IOException(SR.GetString(SR.net_io_readfailure), exception);
}
((NestedSingleAsyncResult)result.AsyncState).InvokeCallback(false);
GlobalLog.Leave("TlsStream#" + ValidationHelper.HashString(this) + "::AsyncReceiveComplete");
}
protected override void Dispose(bool disposing)
{
GlobalLog.Enter("FileWebStream::Close");
try {
if (disposing && m_request != null)
{
m_request.UnblockReader();
}
}
finally {
base.Dispose(disposing);
}
GlobalLog.Leave("FileWebStream::Close");
}