public override int ReadByte()
{
try
{
return(base.ReadByte());
}
catch (HttpListenerException listenerException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
HttpChannelUtilities.CreateCommunicationException(listenerException));
}
}
protected override void OnClose(TimeSpan timeout)
{
base.OnClose(new TimeoutHelper(timeout).RemainingTime());
try
{
this.listenerContext.Response.Close();
}
catch (HttpListenerException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(HttpChannelUtilities.CreateCommunicationException(exception));
}
}
public override int Read(byte[] buffer, int offset, int count)
{
try
{
return(base.Read(buffer, offset, count));
}
catch (HttpListenerException listenerException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
HttpChannelUtilities.CreateCommunicationException(listenerException));
}
}
public override int EndRead(IAsyncResult result)
{
try
{
return(base.EndRead(result));
}
catch (HttpListenerException listenerException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
HttpChannelUtilities.CreateCommunicationException(listenerException));
}
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
try
{
return(base.BeginRead(buffer, offset, count, callback, state));
}
catch (HttpListenerException listenerException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
HttpChannelUtilities.CreateCommunicationException(listenerException));
}
}
internal static Exception ConvertAggregateExceptionToCommunicationException(AggregateException ex)
{
Exception exception = FxTrace.Exception.AsError <WebSocketException>(ex);
WebSocketException webSocketException = exception as WebSocketException;
if (webSocketException != null && webSocketException.InnerException != null)
{
HttpListenerException httpListenerException = webSocketException.InnerException as HttpListenerException;
if (httpListenerException != null)
{
return(HttpChannelUtilities.CreateCommunicationException(httpListenerException));
}
}
ObjectDisposedException objectDisposedException = exception as ObjectDisposedException;
if (objectDisposedException != null)
{
return(new CommunicationObjectAbortedException(exception.Message, exception));
}
return(new CommunicationException(exception.Message, exception));
}
public override int ReadByte()
{
int num;
try
{
num = base.ReadByte();
}
catch (HttpListenerException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(HttpChannelUtilities.CreateCommunicationException(exception));
}
return(num);
}
internal override void OnOpen()
{
listener = new HttpListener();
string host;
switch (HostNameComparisonMode)
{
case HostNameComparisonMode.Exact:
// Uri.DnsSafeHost strips the [], but preserves the scopeid for IPV6 addresses.
if (ListenUri.HostNameType == UriHostNameType.IPv6)
{
host = string.Concat("[", ListenUri.DnsSafeHost, "]");
}
else
{
host = ListenUri.NormalizedHost();
}
break;
case HostNameComparisonMode.StrongWildcard:
host = "+";
break;
case HostNameComparisonMode.WeakWildcard:
host = "*";
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnrecognizedHostNameComparisonMode, HostNameComparisonMode.ToString())));
}
string path = ListenUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
if (!path.StartsWith("/", StringComparison.Ordinal))
{
path = "/" + path;
}
if (!path.EndsWith("/", StringComparison.Ordinal))
{
path = path + "/";
}
string httpListenUrl = string.Concat(Scheme, "://", host, ":", ListenUri.Port, path);
listener.UnsafeConnectionNtlmAuthentication = this.unsafeConnectionNtlmAuthentication;
listener.AuthenticationSchemeSelectorDelegate =
new AuthenticationSchemeSelector(SelectAuthenticationScheme);
if (ExtendedProtectionPolicy.OSSupportsExtendedProtection)
{
//This API will throw if on an unsupported platform.
listener.ExtendedProtectionSelectorDelegate =
new HttpListener.ExtendedProtectionSelector(SelectExtendedProtectionPolicy);
}
if (this.Realm != null)
{
listener.Realm = this.Realm;
}
bool success = false;
try
{
listener.Prefixes.Add(httpListenUrl);
listener.Start();
bool startedListening = false;
try
{
if (Thread.CurrentThread.IsThreadPoolThread)
{
StartListening();
}
else
{
// If we're not on a threadpool thread, then we need to post a callback to start our accepting loop
// Otherwise if the calling thread aborts then the async I/O will get inadvertantly cancelled
listenStartedEvent = new ManualResetEvent(false);
ActionItem.Schedule(OnListening, null);
listenStartedEvent.WaitOne();
listenStartedEvent.Close();
listenStartedEvent = null;
if (listenStartedException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(listenStartedException);
}
}
startedListening = true;
}
finally
{
if (!startedListening)
{
listener.Stop();
}
}
success = true;
}
catch (HttpListenerException listenerException)
{
switch (listenerException.NativeErrorCode)
{
case UnsafeNativeMethods.ERROR_ALREADY_EXISTS:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(SR.GetString(SR.HttpRegistrationAlreadyExists, httpListenUrl), listenerException));
case UnsafeNativeMethods.ERROR_SHARING_VIOLATION:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(SR.GetString(SR.HttpRegistrationPortInUse, httpListenUrl, ListenUri.Port), listenerException));
case UnsafeNativeMethods.ERROR_ACCESS_DENIED:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAccessDeniedException(SR.GetString(SR.HttpRegistrationAccessDenied, httpListenUrl), listenerException));
case UnsafeNativeMethods.ERROR_ALLOTTED_SPACE_EXCEEDED:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.HttpRegistrationLimitExceeded, httpListenUrl), listenerException));
case UnsafeNativeMethods.ERROR_INVALID_PARAMETER:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.HttpInvalidListenURI, ListenUri.OriginalString), listenerException));
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
HttpChannelUtilities.CreateCommunicationException(listenerException));
}
}
finally
{
if (!success)
{
listener.Abort();
}
}
}
internal override void OnOpen()
{
string dnsSafeHost;
this.listener = new HttpListener();
switch (base.HostNameComparisonMode)
{
case HostNameComparisonMode.StrongWildcard:
dnsSafeHost = "+";
break;
case HostNameComparisonMode.Exact:
if (base.ListenUri.HostNameType != UriHostNameType.IPv6)
{
dnsSafeHost = base.ListenUri.DnsSafeHost;
break;
}
dnsSafeHost = "[" + base.ListenUri.DnsSafeHost + "]";
break;
case HostNameComparisonMode.WeakWildcard:
dnsSafeHost = "*";
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("UnrecognizedHostNameComparisonMode", new object[] { base.HostNameComparisonMode.ToString() })));
}
string components = base.ListenUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
if (!components.StartsWith("/", StringComparison.Ordinal))
{
components = "/" + components;
}
if (!components.EndsWith("/", StringComparison.Ordinal))
{
components = components + "/";
}
string uriPrefix = string.Concat(new object[] { this.Scheme, "://", dnsSafeHost, ":", base.ListenUri.Port, components });
this.listener.UnsafeConnectionNtlmAuthentication = this.unsafeConnectionNtlmAuthentication;
this.listener.AuthenticationSchemeSelectorDelegate = new AuthenticationSchemeSelector(this.SelectAuthenticationScheme);
if (ExtendedProtectionPolicy.OSSupportsExtendedProtection)
{
this.listener.ExtendedProtectionSelectorDelegate = new HttpListener.ExtendedProtectionSelector(this.SelectExtendedProtectionPolicy);
}
if (base.Realm != null)
{
this.listener.Realm = base.Realm;
}
bool flag = false;
try
{
this.listener.Prefixes.Add(uriPrefix);
this.listener.Start();
bool flag2 = false;
try
{
if (Thread.CurrentThread.IsThreadPoolThread)
{
this.StartListening();
}
else
{
this.listenStartedEvent = new ManualResetEvent(false);
ActionItem.Schedule(new Action <object>(this.OnListening), null);
this.listenStartedEvent.WaitOne();
this.listenStartedEvent.Close();
this.listenStartedEvent = null;
if (this.listenStartedException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.listenStartedException);
}
}
flag2 = true;
}
finally
{
if (!flag2)
{
this.listener.Stop();
}
}
flag = true;
}
catch (HttpListenerException exception)
{
switch (exception.NativeErrorCode)
{
case 0x57:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("HttpInvalidListenURI", new object[] { base.ListenUri.OriginalString }), exception));
case 0xb7:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(System.ServiceModel.SR.GetString("HttpRegistrationAlreadyExists", new object[] { uriPrefix }), exception));
case 0x540:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("HttpRegistrationLimitExceeded", new object[] { uriPrefix }), exception));
case 5:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAccessDeniedException(System.ServiceModel.SR.GetString("HttpRegistrationAccessDenied", new object[] { uriPrefix }), exception));
case 0x20:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(System.ServiceModel.SR.GetString("HttpRegistrationPortInUse", new object[] { uriPrefix, base.ListenUri.Port }), exception));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(HttpChannelUtilities.CreateCommunicationException(exception));
}
finally
{
if (!flag)
{
this.listener.Abort();
}
}
}