private static void removePrefix(string uriPrefix, WebSocketSharp.Net.HttpListener listener)
{
int num;
EndPointListener endPointListener;
HttpListenerPrefix httpListenerPrefix = new HttpListenerPrefix(uriPrefix);
IPAddress pAddress = EndPointManager.convertToIPAddress(httpListenerPrefix.Host);
if (pAddress.IsLocal())
{
if (int.TryParse(httpListenerPrefix.Port, out num))
{
if (num.IsPortNumber())
{
string path = httpListenerPrefix.Path;
if (path.IndexOf('%') == -1)
{
if (path.IndexOf("//", StringComparison.Ordinal) == -1)
{
IPEndPoint pEndPoint = new IPEndPoint(pAddress, num);
if (EndPointManager._endpoints.TryGetValue(pEndPoint, out endPointListener))
{
if (!(endPointListener.IsSecure ^ httpListenerPrefix.IsSecure))
{
endPointListener.RemovePrefix(httpListenerPrefix, listener);
}
}
}
}
}
}
}
}
public static void AddListener(WebSocketSharp.Net.HttpListener listener)
{
List <string> strs = new List <string>();
object syncRoot = ((ICollection)EndPointManager._endpoints).SyncRoot;
Monitor.Enter(syncRoot);
try
{
try
{
foreach (string prefix in listener.Prefixes)
{
EndPointManager.addPrefix(prefix, listener);
strs.Add(prefix);
}
}
catch
{
foreach (string str in strs)
{
EndPointManager.removePrefix(str, listener);
}
throw;
}
}
finally
{
Monitor.Exit(syncRoot);
}
}
public ResponseStream GetResponseStream()
{
ResponseStream responseStream;
if ((this._outputStream != null ? false : this._socket != null))
{
object obj = this._sync;
Monitor.Enter(obj);
try
{
if (this._socket != null)
{
WebSocketSharp.Net.HttpListener listener = this._context.Listener;
bool flag = (listener != null ? listener.IgnoreWriteExceptions : true);
this._outputStream = new ResponseStream(this._stream, this._context.Response, flag);
responseStream = this._outputStream;
}
else
{
responseStream = this._outputStream;
}
}
finally
{
Monitor.Exit(obj);
}
}
else
{
responseStream = this._outputStream;
}
return(responseStream);
}
private static WebSocketSharp.Net.HttpListener searchHttpListenerFromSpecial(string path, List <HttpListenerPrefix> prefixes)
{
WebSocketSharp.Net.HttpListener httpListener;
if (prefixes != null)
{
WebSocketSharp.Net.HttpListener listener = null;
int num = -1;
foreach (HttpListenerPrefix prefix in prefixes)
{
string str = prefix.Path;
int length = str.Length;
if (length >= num)
{
if (path.StartsWith(str))
{
num = length;
listener = prefix.Listener;
}
}
}
httpListener = listener;
}
else
{
httpListener = null;
}
return(httpListener);
}
/*
* Starts the server.
*/
public void Start()
{
// Throw an exception if the server is running.
if (this.Running)
{
throw new WebException("Server is already running. Stop the server before running.");
}
// Set up the HTTP listener.
this.Running = true;
this.Listener = new HttpListener();
foreach (var prefix in this.Prefixes)
{
this.Listener.Prefixes.Add(prefix);
}
this.Listener.Start();
// Run a loop to accept client connections until it is closed.
while (Running)
{
// Start the context fetching async and wait for it to be completed or to be cancelled.
var task = Task.Run(() => this.Listener.GetContext());
task.ContinueWith((result) =>
{
this.HandleRequest(result.Result);
this.ConnectionAcceptedEvent.Set();
});
// Wait for a connection to be accepted or the listener to close.
this.ConnectionAcceptedEvent.WaitOne();
}
// Signal that the loop ended.
this.ConnectionLoopEndedEvent.Set();
}
public static void AddPrefix(string uriPrefix, WebSocketSharp.Net.HttpListener listener)
{
object syncRoot = ((ICollection)EndPointManager._endpoints).SyncRoot;
Monitor.Enter(syncRoot);
try
{
EndPointManager.addPrefix(uriPrefix, listener);
}
finally
{
Monitor.Exit(syncRoot);
}
}
public void AddPrefix(HttpListenerPrefix prefix, WebSocketSharp.Net.HttpListener listener)
{
List <HttpListenerPrefix> httpListenerPrefixes;
List <HttpListenerPrefix> httpListenerPrefixes1;
Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> httpListenerPrefixes2;
Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> httpListenerPrefixes3;
if (prefix.Host == "*")
{
do
{
httpListenerPrefixes = this._unhandled;
httpListenerPrefixes1 = (httpListenerPrefixes != null ? new List <HttpListenerPrefix>(httpListenerPrefixes) : new List <HttpListenerPrefix>());
prefix.Listener = listener;
EndPointListener.addSpecial(httpListenerPrefixes1, prefix);
}while (Interlocked.CompareExchange <List <HttpListenerPrefix> >(ref this._unhandled, httpListenerPrefixes1, httpListenerPrefixes) != httpListenerPrefixes);
}
else if (prefix.Host != "+")
{
do
{
httpListenerPrefixes2 = this._prefixes;
if (!httpListenerPrefixes2.ContainsKey(prefix))
{
httpListenerPrefixes3 = new Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener>(httpListenerPrefixes2);
httpListenerPrefixes3[prefix] = listener;
}
else
{
if (httpListenerPrefixes2[prefix] != listener)
{
throw new WebSocketSharp.Net.HttpListenerException(87, string.Format("There's another listener for {0}.", prefix));
}
break;
}
}while (Interlocked.CompareExchange <Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> >(ref this._prefixes, httpListenerPrefixes3, httpListenerPrefixes2) != httpListenerPrefixes2);
}
else
{
do
{
httpListenerPrefixes = this._all;
httpListenerPrefixes1 = (httpListenerPrefixes != null ? new List <HttpListenerPrefix>(httpListenerPrefixes) : new List <HttpListenerPrefix>());
prefix.Listener = listener;
EndPointListener.addSpecial(httpListenerPrefixes1, prefix);
}while (Interlocked.CompareExchange <List <HttpListenerPrefix> >(ref this._all, httpListenerPrefixes1, httpListenerPrefixes) != httpListenerPrefixes);
}
}
public static void RemoveListener(WebSocketSharp.Net.HttpListener listener)
{
object syncRoot = ((ICollection)EndPointManager._endpoints).SyncRoot;
Monitor.Enter(syncRoot);
try
{
foreach (string prefix in listener.Prefixes)
{
EndPointManager.removePrefix(prefix, listener);
}
}
finally
{
Monitor.Exit(syncRoot);
}
}
private static void addPrefix(string uriPrefix, WebSocketSharp.Net.HttpListener listener)
{
int num;
EndPointListener endPointListener;
HttpListenerPrefix httpListenerPrefix = new HttpListenerPrefix(uriPrefix);
IPAddress pAddress = EndPointManager.convertToIPAddress(httpListenerPrefix.Host);
if (!pAddress.IsLocal())
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid host.");
}
if (!int.TryParse(httpListenerPrefix.Port, out num))
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid port.");
}
if (!num.IsPortNumber())
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid port.");
}
string path = httpListenerPrefix.Path;
if (path.IndexOf('%') != -1)
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid path.");
}
if (path.IndexOf("//", StringComparison.Ordinal) != -1)
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid path.");
}
IPEndPoint pEndPoint = new IPEndPoint(pAddress, num);
if (!EndPointManager._endpoints.TryGetValue(pEndPoint, out endPointListener))
{
endPointListener = new EndPointListener(pEndPoint, httpListenerPrefix.IsSecure, listener.CertificateFolderPath, listener.SslConfiguration, listener.ReuseAddress);
EndPointManager._endpoints.Add(pEndPoint, endPointListener);
}
else if (endPointListener.IsSecure ^ httpListenerPrefix.IsSecure)
{
throw new WebSocketSharp.Net.HttpListenerException(87, "Includes an invalid scheme.");
}
endPointListener.AddPrefix(httpListenerPrefix, listener);
}
/*
* Stops the server.
*/
public void Stop()
{
// Throw an exception if the server isn't running.
if (!this.Running)
{
throw new WebException("Server isn't running. Start the server before stopping.");
}
// Close the listener.
this.Running = false;
foreach (var prefix in this.Listener.Prefixes.ToArray())
{
this.Listener.Prefixes.Remove(prefix);
}
this.Listener.Stop();
this.Listener = null;
// Signal to end the loop and wait for the loop to end.
this.ConnectionAcceptedEvent.Set();
this.ConnectionLoopEndedEvent.WaitOne();
}
private void Start(string host, int port, WebServerSslConfig sslConfig)
{
_listener = new HttpListener();
if (sslConfig == null)
{
_logger.Info($"Starting HTTP server on {host}:{port}");
_listener.Prefixes.Add($"http://{host}:{port}/");
}
else
{
_logger.Info($"Starting HTTPS server on {host}:{port}");
_listener.Prefixes.Add($"https://{host}:{port}/");
_listener.SslConfiguration.EnabledSslProtocols = sslConfig.EnabledSslProtocols;
_listener.SslConfiguration.ServerCertificate = Utils.LoadPemCertificate(sslConfig.CertificatePath, sslConfig.KeyPath);
_listener.SslConfiguration.ClientCertificateRequired = sslConfig.ClientCertificateRequired;
_listener.SslConfiguration.CheckCertificateRevocation = false;
_listener.SslConfiguration.ClientCertificateValidationCallback = sslConfig.ClientCertificateValidationCallback;
}
_listener.Start();
}
internal bool TrySearchHttpListener(Uri uri, out WebSocketSharp.Net.HttpListener listener)
{
bool flag;
listener = null;
if (uri != null)
{
string host = uri.Host;
bool flag1 = Uri.CheckHostName(host) == UriHostNameType.Dns;
string str = uri.Port.ToString();
string str1 = HttpUtility.UrlDecode(uri.AbsolutePath);
string str2 = (str1[str1.Length - 1] != '/' ? string.Concat(str1, "/") : str1);
if ((host == null ? false : host.Length > 0))
{
int num = -1;
foreach (HttpListenerPrefix key in this._prefixes.Keys)
{
if (flag1)
{
string host1 = key.Host;
if ((Uri.CheckHostName(host1) != UriHostNameType.Dns ? false : host1 != host))
{
continue;
}
}
if (key.Port == str)
{
string path = key.Path;
int length = path.Length;
if (length >= num)
{
if ((str1.StartsWith(path) ? true : str2.StartsWith(path)))
{
num = length;
listener = this._prefixes[key];
}
}
}
}
if (num != -1)
{
flag = true;
return(flag);
}
}
List <HttpListenerPrefix> httpListenerPrefixes = this._unhandled;
listener = EndPointListener.searchHttpListenerFromSpecial(str1, httpListenerPrefixes);
if ((listener != null ? false : str2 != str1))
{
listener = EndPointListener.searchHttpListenerFromSpecial(str2, httpListenerPrefixes);
}
if (listener == null)
{
httpListenerPrefixes = this._all;
listener = EndPointListener.searchHttpListenerFromSpecial(str1, httpListenerPrefixes);
if ((listener != null ? false : str2 != str1))
{
listener = EndPointListener.searchHttpListenerFromSpecial(str2, httpListenerPrefixes);
}
flag = listener != null;
}
else
{
flag = true;
}
}
else
{
flag = false;
}
return(flag);
}
public void RemovePrefix(HttpListenerPrefix prefix, WebSocketSharp.Net.HttpListener listener)
{
List <HttpListenerPrefix> httpListenerPrefixes;
List <HttpListenerPrefix> httpListenerPrefixes1;
Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> httpListenerPrefixes2;
Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> httpListenerPrefixes3;
if (prefix.Host == "*")
{
do
{
httpListenerPrefixes = this._unhandled;
if (httpListenerPrefixes != null)
{
httpListenerPrefixes1 = new List <HttpListenerPrefix>(httpListenerPrefixes);
if (EndPointListener.removeSpecial(httpListenerPrefixes1, prefix))
{
continue;
}
break;
}
else
{
break;
}
}while (Interlocked.CompareExchange <List <HttpListenerPrefix> >(ref this._unhandled, httpListenerPrefixes1, httpListenerPrefixes) != httpListenerPrefixes);
this.leaveIfNoPrefix();
}
else if (prefix.Host != "+")
{
do
{
httpListenerPrefixes2 = this._prefixes;
if (httpListenerPrefixes2.ContainsKey(prefix))
{
httpListenerPrefixes3 = new Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener>(httpListenerPrefixes2);
httpListenerPrefixes3.Remove(prefix);
}
else
{
break;
}
}while (Interlocked.CompareExchange <Dictionary <HttpListenerPrefix, WebSocketSharp.Net.HttpListener> >(ref this._prefixes, httpListenerPrefixes3, httpListenerPrefixes2) != httpListenerPrefixes2);
this.leaveIfNoPrefix();
}
else
{
do
{
httpListenerPrefixes = this._all;
if (httpListenerPrefixes != null)
{
httpListenerPrefixes1 = new List <HttpListenerPrefix>(httpListenerPrefixes);
if (EndPointListener.removeSpecial(httpListenerPrefixes1, prefix))
{
continue;
}
break;
}
else
{
break;
}
}while (Interlocked.CompareExchange <List <HttpListenerPrefix> >(ref this._all, httpListenerPrefixes1, httpListenerPrefixes) != httpListenerPrefixes);
this.leaveIfNoPrefix();
}
}
