private static EndPointListener getEndPointListener(HttpListenerPrefix prefix, HttpListener listener)
{
IPAddress key = convertToIPAddress(prefix.Host);
Dictionary <int, EndPointListener> dictionary = null;
if (_addressToEndpoints.ContainsKey(key))
{
dictionary = _addressToEndpoints[key];
}
else
{
dictionary = new Dictionary <int, EndPointListener>();
_addressToEndpoints[key] = dictionary;
}
int port = prefix.Port;
EndPointListener listener2 = null;
if (dictionary.ContainsKey(port))
{
listener2 = dictionary[port];
}
else
{
listener2 = new EndPointListener(key, port, listener.ReuseAddress, prefix.IsSecure, listener.CertificateFolderPath, listener.SslConfiguration);
dictionary[port] = listener2;
}
return(listener2);
}
private static void processAccepted(Socket socket, EndPointListener listener)
#endif
{
listener.Log.Debug("processAccepted from: {0}", socket.RemoteEndPoint);
HttpConnection conn = null;
try
{
conn = new HttpConnection(socket, listener);
lock (listener._unregisteredSync)
listener._unregistered[conn] = conn;
conn.BeginReadRequest();
}
catch
{
if (conn != null)
{
conn.Close(true);
return;
}
socket.Close();
}
}
private static void processAccepted(Socket socket, EndPointListener listener)
{
HttpConnection conn = null;
try
{
conn = new HttpConnection(socket, listener);
lock (listener._unregisteredSync)
{
listener._unregistered[conn] = conn;
}
conn.BeginReadRequest();
}
catch
{
if (conn != null)
{
conn.Close(true);
return;
}
socket.Close();
}
}
public HttpConnection(
Socket sock,
EndPointListener epl,
bool secure,
X509Certificate2 cert,
AsymmetricAlgorithm key
)
{
this.sock = sock;
this.epl = epl;
this.secure = secure;
this.key = key;
// if (secure == false) {
// stream = new NetworkStream (sock, false);
// } else {
// var ssl_stream = new SslServerStream (new NetworkStream (sock, false), cert, false, false);
// ssl_stream.PrivateKeyCertSelectionDelegate += OnPVKSelection;
// stream = ssl_stream;
// }
var net_stream = new NetworkStream(sock, false);
if (!secure)
{
stream = net_stream;
}
else
{
var ssl_stream = new SslStream(net_stream, false);
ssl_stream.AuthenticateAsServer(cert);
stream = ssl_stream;
}
timer = new Timer(OnTimeout, null, Timeout.Infinite, Timeout.Infinite);
Init();
}
private static EndPointListener getEndPointListener(IPAddress address, int port, HttpListener httpListener, bool secure)
{
Dictionary <int, EndPointListener> dictionary;
if (EndPointManager._ipToEndpoints.ContainsKey(address))
{
dictionary = EndPointManager._ipToEndpoints[address];
}
else
{
dictionary = new Dictionary <int, EndPointListener>();
EndPointManager._ipToEndpoints[address] = dictionary;
}
EndPointListener endPointListener;
if (dictionary.ContainsKey(port))
{
endPointListener = dictionary[port];
}
else
{
endPointListener = new EndPointListener(address, port, secure, httpListener.CertificateFolderPath, httpListener.DefaultCertificate);
dictionary[port] = endPointListener;
}
return(endPointListener);
}
internal HttpConnection(Socket socket, EndPointListener listener)
{
_socket = socket;
_listener = listener;
_secure = listener.IsSecure;
var netStream = new NetworkStream(socket, false);
if (_secure)
{
var conf = listener.SslConfiguration;
var sslStream = new SslStream(netStream, false, conf.ClientCertificateValidationCallback);
sslStream.AuthenticateAsServer(
conf.ServerCertificate,
conf.ClientCertificateRequired,
conf.EnabledSslProtocols,
conf.CheckCertificateRevocation);
_stream = sslStream;
}
else
{
_stream = netStream;
}
_sync = new object();
_timeout = 90000; // 90k ms for first request, 15k ms from then on.
_timer = new Timer(onTimeout, this, Timeout.Infinite, Timeout.Infinite);
init();
}
private static EndPointListener getEndPointListener(
IPAddress address, int port, HttpListener httpListener, bool secure)
{
Dictionary <int, EndPointListener> endpoints = null;
if (_ipToEndpoints.ContainsKey(address))
{
endpoints = _ipToEndpoints [address];
}
else
{
endpoints = new Dictionary <int, EndPointListener> ();
_ipToEndpoints [address] = endpoints;
}
EndPointListener epListener = null;
if (endpoints.ContainsKey(port))
{
epListener = endpoints [port];
}
else
{
epListener = new EndPointListener(
address,
port,
secure,
httpListener.CertificateFolderPath,
httpListener.DefaultCertificate);
endpoints [port] = epListener;
}
return(epListener);
}
private static void removePrefix(string uriPrefix, HttpListener listener)
{
HttpListenerPrefix httpListenerPrefix = new HttpListenerPrefix(uriPrefix);
if (httpListenerPrefix.Path.IndexOf('%') == -1 && httpListenerPrefix.Path.IndexOf("//", StringComparison.Ordinal) == -1)
{
EndPointListener endPointListener = getEndPointListener(httpListenerPrefix.Host, httpListenerPrefix.Port, listener, httpListenerPrefix.IsSecure);
endPointListener.RemovePrefix(httpListenerPrefix, listener);
}
}
private static bool tryGetEndPointListener(
IPAddress address, int port, out EndPointListener listener
)
{
listener = null;
Dictionary <int, EndPointListener> endpoints;
return(_addressToEndpoints.TryGetValue(address, out endpoints) &&
endpoints.TryGetValue(port, out listener));
}
private static EndPointListener getEndPointListener(
string host, int port, HttpListener httpListener, bool secure)
{
IPAddress addr;
if (host == "*")
{
addr = IPAddress.Any;
}
else if (!IPAddress.TryParse(host, out addr))
{
try {
var iphost = Dns.GetHostEntry(host);
addr = iphost != null ? iphost.AddressList[0] : IPAddress.Any;
}
catch {
addr = IPAddress.Any;
}
}
Dictionary <int, EndPointListener> eps = null;
if (_ipToEndpoints.ContainsKey(addr))
{
eps = _ipToEndpoints[addr];
}
else
{
eps = new Dictionary <int, EndPointListener> ();
_ipToEndpoints[addr] = eps;
}
EndPointListener epl = null;
if (eps.ContainsKey(port))
{
epl = eps[port];
}
else
{
epl = new EndPointListener(
addr,
port,
secure,
httpListener.CertificateFolderPath,
httpListener.SslConfiguration,
httpListener.ReuseAddress);
eps[port] = epl;
}
return(epl);
}
public void AddPrefix(ListenerPrefix prefix, HttpListener listener)
{
if (prefix.Host == "*")
{
List <ListenerPrefix> list;
List <ListenerPrefix> list2;
do
{
list = this._unhandled;
list2 = ((list == null) ? new List <ListenerPrefix>() : new List <ListenerPrefix>(list));
prefix.Listener = listener;
EndPointListener.addSpecial(list2, prefix);
}while (Interlocked.CompareExchange <List <ListenerPrefix> >(ref this._unhandled, list2, list) != list);
return;
}
if (prefix.Host == "+")
{
List <ListenerPrefix> list;
List <ListenerPrefix> list2;
do
{
list = this._all;
list2 = ((list == null) ? new List <ListenerPrefix>() : new List <ListenerPrefix>(list));
prefix.Listener = listener;
EndPointListener.addSpecial(list2, prefix);
}while (Interlocked.CompareExchange <List <ListenerPrefix> >(ref this._all, list2, list) != list);
return;
}
Dictionary <ListenerPrefix, HttpListener> prefixes;
for (;;)
{
prefixes = this._prefixes;
if (prefixes.ContainsKey(prefix))
{
break;
}
Dictionary <ListenerPrefix, HttpListener> dictionary = new Dictionary <ListenerPrefix, HttpListener>(prefixes);
dictionary[prefix] = listener;
if (Interlocked.CompareExchange <Dictionary <ListenerPrefix, HttpListener> >(ref this._prefixes, dictionary, prefixes) == prefixes)
{
return;
}
}
HttpListener httpListener = prefixes[prefix];
if (httpListener != listener)
{
throw new HttpListenerException(400, "There's another listener for " + prefix);
}
return;
}
public static void RemoveEndPoint(EndPointListener epl, IPEndPoint ep)
{
lock (((ICollection)ip_to_endpoints).SyncRoot) {
Dictionary <int, EndPointListener> p = null;
p = ip_to_endpoints [ep.Address];
p.Remove(ep.Port);
if (p.Count == 0)
{
ip_to_endpoints.Remove(ep.Address);
}
epl.Close();
}
}
public static void RemoveEndPoint(EndPointListener epListener, IPEndPoint endpoint)
{
lock (((ICollection)_ipToEndpoints).SyncRoot) {
var eps = _ipToEndpoints[endpoint.Address];
eps.Remove(endpoint.Port);
if (eps.Count == 0)
{
_ipToEndpoints.Remove(endpoint.Address);
}
epListener.Close();
}
}
private static void onAccept(object sender, EventArgs e)
{
SocketAsyncEventArgs socketAsyncEventArgs = (SocketAsyncEventArgs)e;
EndPointListener endPointListener = (EndPointListener)socketAsyncEventArgs.UserToken;
Socket socket = null;
if (socketAsyncEventArgs.SocketError == SocketError.Success)
{
socket = socketAsyncEventArgs.AcceptSocket;
socketAsyncEventArgs.AcceptSocket = null;
}
try
{
endPointListener._socket.AcceptAsync(socketAsyncEventArgs);
}
catch
{
if (socket != null)
{
socket.Close();
}
return;
}
if (socket == null)
{
return;
}
HttpConnection httpConnection = null;
try
{
httpConnection = new HttpConnection(socket, endPointListener, endPointListener._secure, endPointListener._cert);
object syncRoot = ((ICollection)endPointListener._unregistered).SyncRoot;
lock (syncRoot)
{
endPointListener._unregistered[httpConnection] = httpConnection;
}
httpConnection.BeginReadRequest();
}
catch
{
if (httpConnection != null)
{
httpConnection.Close(true);
}
else
{
socket.Close();
}
}
}
internal static void RemoveEndPoint(EndPointListener listener)
{
lock (((ICollection)_addressToEndpoints).SyncRoot)
{
IPAddress address = listener.Address;
Dictionary <int, EndPointListener> dictionary = _addressToEndpoints[address];
dictionary.Remove(listener.Port);
if (dictionary.Count == 0)
{
_addressToEndpoints.Remove(address);
}
listener.Close();
}
}
internal static void RemoveEndPoint(EndPointListener listener)
{
lock (((ICollection)_addressToEndpoints).SyncRoot) {
var addr = listener.Address;
var eps = _addressToEndpoints[addr];
eps.Remove(listener.Port);
if (eps.Count == 0)
{
_addressToEndpoints.Remove(addr);
}
listener.Close();
}
}
private static void setEndPointListener(EndPointListener listener)
{
var addr = listener.Address;
Dictionary <int, EndPointListener> endpoints;
if (!_addressToEndpoints.TryGetValue(addr, out endpoints))
{
endpoints = new Dictionary <int, EndPointListener> ();
_addressToEndpoints[addr] = endpoints;
}
endpoints[listener.Port] = listener;
}
public void RemovePrefix(ListenerPrefix prefix, HttpListener listener)
{
if (prefix.Host == "*")
{
List <ListenerPrefix> list;
List <ListenerPrefix> list2;
do
{
list = this._unhandled;
list2 = ((list == null) ? new List <ListenerPrefix>() : new List <ListenerPrefix>(list));
if (!EndPointListener.removeSpecial(list2, prefix))
{
break;
}
}while (Interlocked.CompareExchange <List <ListenerPrefix> >(ref this._unhandled, list2, list) != list);
this.checkIfRemove();
return;
}
if (prefix.Host == "+")
{
List <ListenerPrefix> list;
List <ListenerPrefix> list2;
do
{
list = this._all;
list2 = ((list == null) ? new List <ListenerPrefix>() : new List <ListenerPrefix>(list));
if (!EndPointListener.removeSpecial(list2, prefix))
{
break;
}
}while (Interlocked.CompareExchange <List <ListenerPrefix> >(ref this._all, list2, list) != list);
this.checkIfRemove();
return;
}
Dictionary <ListenerPrefix, HttpListener> prefixes;
Dictionary <ListenerPrefix, HttpListener> dictionary;
do
{
prefixes = this._prefixes;
if (!prefixes.ContainsKey(prefix))
{
break;
}
dictionary = new Dictionary <ListenerPrefix, HttpListener>(prefixes);
dictionary.Remove(prefix);
}while (Interlocked.CompareExchange <Dictionary <ListenerPrefix, HttpListener> >(ref this._prefixes, dictionary, prefixes) != prefixes);
this.checkIfRemove();
}
public static void RemoveEndPoint(EndPointListener epListener, IPEndPoint endpoint)
{
object syncRoot = ((ICollection)EndPointManager._ipToEndpoints).SyncRoot;
lock (syncRoot)
{
Dictionary <int, EndPointListener> dictionary = EndPointManager._ipToEndpoints[endpoint.Address];
dictionary.Remove(endpoint.Port);
if (dictionary.Count == 0)
{
EndPointManager._ipToEndpoints.Remove(endpoint.Address);
}
epListener.Close();
}
}
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);
}
}
private static void addPrefix(string uriPrefix, HttpListener httpListener)
{
ListenerPrefix listenerPrefix = new ListenerPrefix(uriPrefix);
if (listenerPrefix.Path.IndexOf('%') != -1)
{
throw new HttpListenerException(400, "Invalid path.");
}
if (listenerPrefix.Path.IndexOf("//", StringComparison.Ordinal) != -1)
{
throw new HttpListenerException(400, "Invalid path.");
}
EndPointListener endPointListener = EndPointManager.getEndPointListener(IPAddress.Any, listenerPrefix.Port, httpListener, listenerPrefix.Secure);
endPointListener.AddPrefix(listenerPrefix, httpListener);
}
private static void removePrefix(string uriPrefix, HttpListener httpListener)
{
ListenerPrefix listenerPrefix = new ListenerPrefix(uriPrefix);
if (listenerPrefix.Path.IndexOf('%') != -1)
{
return;
}
if (listenerPrefix.Path.IndexOf("//", StringComparison.Ordinal) != -1)
{
return;
}
EndPointListener endPointListener = EndPointManager.getEndPointListener(IPAddress.Any, listenerPrefix.Port, httpListener, listenerPrefix.Secure);
endPointListener.RemovePrefix(listenerPrefix, httpListener);
}
private static void addPrefix(string uriPrefix, HttpListener listener)
{
HttpListenerPrefix httpListenerPrefix = new HttpListenerPrefix(uriPrefix);
if (httpListenerPrefix.Path.IndexOf('%') != -1)
{
throw new HttpListenerException(400, "Invalid path.");
}
if (httpListenerPrefix.Path.IndexOf("//", StringComparison.Ordinal) != -1)
{
throw new HttpListenerException(400, "Invalid path.");
}
EndPointListener endPointListener = getEndPointListener(httpListenerPrefix.Host, httpListenerPrefix.Port, listener, httpListenerPrefix.IsSecure);
endPointListener.AddPrefix(httpListenerPrefix, listener);
}
private static EndPointListener getEndPointListener(string host, int port, HttpListener listener, bool secure)
{
IPAddress iPAddress = convertToAddress(host);
Dictionary <int, EndPointListener> dictionary = null;
if (_addressToEndpoints.ContainsKey(iPAddress))
{
dictionary = _addressToEndpoints[iPAddress];
}
else
{
dictionary = new Dictionary <int, EndPointListener>();
_addressToEndpoints[iPAddress] = dictionary;
}
EndPointListener endPointListener = null;
return(dictionary.ContainsKey(port) ? dictionary[port] : (dictionary[port] = new EndPointListener(iPAddress, port, secure, listener.CertificateFolderPath, listener.SslConfiguration, listener.ReuseAddress)));
}
static void RemovePrefixInternal(string prefix, HttpListener listener)
{
ListenerPrefix lp = new ListenerPrefix(prefix);
if (lp.Path.IndexOf('%') != -1)
{
return;
}
if (lp.Path.IndexOf("//", StringComparison.Ordinal) != -1)
{
return;
}
EndPointListener epl = GetEPListener(IPAddress.Any, lp.Port, listener, lp.Secure);
epl.RemovePrefix(lp, listener);
}
static void AddPrefixInternal(string p, HttpListener listener)
{
ListenerPrefix lp = new ListenerPrefix(p);
if (lp.Path.IndexOf('%') != -1)
{
throw new HttpListenerException(400, "Invalid path.");
}
if (lp.Path.IndexOf("//", StringComparison.Ordinal) != -1) // TODO: Code?
{
throw new HttpListenerException(400, "Invalid path.");
}
// Always listens on all the interfaces, no matter the host name/ip used.
EndPointListener epl = GetEPListener(IPAddress.Any, lp.Port, listener, lp.Secure);
epl.AddPrefix(lp, listener);
}
private static EndPointListener getEndPointListener(
HttpListenerPrefix prefix, HttpListener listener
)
{
var addr = convertToIPAddress(prefix.Host);
Dictionary <int, EndPointListener> eps = null;
if (_addressToEndpoints.ContainsKey(addr))
{
eps = _addressToEndpoints[addr];
}
else
{
eps = new Dictionary <int, EndPointListener> ();
_addressToEndpoints[addr] = eps;
}
var port = prefix.Port;
EndPointListener lsnr = null;
if (eps.ContainsKey(port))
{
lsnr = eps[port];
}
else
{
lsnr =
new EndPointListener(
addr,
port,
listener.ReuseAddress,
prefix.IsSecure,
listener.CertificateFolderPath,
listener.SslConfiguration
);
eps[port] = lsnr;
}
return(lsnr);
}
private static X509Certificate2 getCertificate(int port, string certFolderPath, X509Certificate2 defaultCert)
{
try
{
string text = Path.Combine(certFolderPath, string.Format("{0}.cer", port));
string text2 = Path.Combine(certFolderPath, string.Format("{0}.key", port));
if (File.Exists(text) && File.Exists(text2))
{
return(new X509Certificate2(text)
{
PrivateKey = EndPointListener.createRSAFromFile(text2)
});
}
}
catch
{
}
return(defaultCert);
}
static void OnAccept(object sender, EventArgs e)
{
SocketAsyncEventArgs args = (SocketAsyncEventArgs)e;
EndPointListener epl = (EndPointListener)args.UserToken;
Socket accepted = null;
if (args.SocketError == SocketError.Success)
{
accepted = args.AcceptSocket;
args.AcceptSocket = null;
}
try {
if (epl.sock != null)
{
epl.sock.AcceptAsync(args);
}
} catch {
if (accepted != null)
{
try {
accepted.Close();
} catch {}
accepted = null;
}
}
if (accepted == null)
{
return;
}
if (epl.secure && (epl.cert == null || epl.key == null))
{
accepted.Close();
return;
}
HttpConnection conn = new HttpConnection(accepted, epl, epl.secure, epl.cert, epl.key);
epl.unregistered [conn] = conn;
conn.BeginReadRequest();
}
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);
}
