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); }