// initialize git repo as follow // > mkdir repository // > cd repository // > git init . // > git config receive.denyCurrentBranch ignore static void Main(string[] args) { if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.Unix) { GitExe = "/usr/bin/git"; } try { RepositoryPath = args[0]; var port = Int32.Parse(args[1]); string prefix = String.Format("http://localhost:{0}/", port); var listener = new HttpListener(); listener.Prefixes.Add(prefix); listener.Start(); Console.WriteLine("Listening at " + prefix); while (true) { // simple handle one request at a time ProcessRequest(listener.GetContext()); } } catch (Exception ex) { Console.WriteLine(ex); } }
public Server(string host, int port, Func<IRequestHandler> handlerFactory) { _listener = new HttpListener(); _Binding = string.Format("http://{0}:{1}/", host, port); _listener.Prefixes.Add(_Binding); _HandlerFactory = handlerFactory; }
private void EndGetRequest(IAsyncResult result) { HttpListenerContext context = null; System.Net.HttpListener listener = (System.Net.HttpListener)result.AsyncState; try { context = listener.EndGetContext(result); using (context.Response) HandleRequest(context); } catch (Exception ex) { Console.Write("Exception in listener: {0}{1}", Environment.NewLine, ex); } finally { try { if (listener.IsListening) { listener.BeginGetContext(EndGetRequest, listener); } } catch { Stop(); } } }
/// <summary> /// 启动 /// </summary> public async void StartAsync() { var listener = new System.Net.HttpListener(); listener.Prefixes.Add($"http://{_endPoint.ToString()}/GarbageBin/Data/"); // 启动服务器 try { listener.Start(); } catch (Exception ex) { Console.WriteLine($"智慧垃圾桶,启动服务器失败,{ex.ToString()}"); return; } // 消息接收 while (true) { try { var context = await listener.GetContextAsync(); var result = await ReceiveMessage(context); await SendResponse(context, result); } catch (Exception ex) { Console.WriteLine($"智慧垃圾桶,获取请求失败,{ex.ToString()}"); } } }
/// <summary> /// Starts the Authorisation listener to listen to the specified port. /// </summary> /// <param name="port"></param> public void ListenTo(int port) { if (!HttpListener.IsSupported) { Debug.Write("AuthListener unsupported: Windows XP SP2 or Server 2003 is required"); throw new NotSupportedException("Windows XP SP2 or Server 2003 is required to use the HttpListener class."); } try { this._server = new HttpListener(); var prefix = String.Format("http://localhost:{0}/", port); this._server.Prefixes.Add(prefix); Debug.WriteLine("Prefix " + prefix + " added."); // Start listening for client requests. this._server.Start(); Debug.WriteLine("Waiting for a connection... "); // Start waiting for a request _server.BeginGetContext(new AsyncCallback(ListenerCallback), _server); } catch (SocketException e) { Console.WriteLine("SocketException: {0}", e); this.Stop(); } }
public static void GetContext(System.Net.HttpListener listener, Action <Exception, System.Net.HttpListenerContext> callback) { try { listener.BeginGetContext((result) => { try { var context = listener.EndGetContext(result); Loop.Post(() => { callback(null, context); }); } catch (Exception exception) { Loop.Post(() => { callback(exception, null); }); } }, null); } catch (Exception exception) { callback(exception, null); } }
public static HttpListener CreateAndStartListener (string prefix) { HttpListener listener = new HttpListener (); listener.Prefixes.Add (prefix); listener.Start (); return listener; }
/// <summary> /// Http监听器 /// </summary> /// <param name="host">监听host</param> /// <param name="port">监听端口</param> public HttpListener(string host = "*", int port = 9478) { listener = new Listener(); listener.Prefixes.Add("http://" + host + ":" + port + "/"); listener.Start(); listener.BeginGetContext(ListenedRequest, null); }
public void Start() { httpListener = new HttpListener(); httpListener.Prefixes.Add("http://localhost:" + this.ListenPort + "/"); httpListener.Start(); httpListener.BeginGetContext(this.OnNewRequest, null); }
// Methods protected override Task ExecuteAsync(CancellationToken stoppingToken) { return(Task.Run(() => { // Variables HttpListener httpListener = null; HttpListenerContext httpContext = null; // Execute try { // HttpListener httpListener = new System.Net.HttpListener(); httpListener.Prefixes.Add(@"http://*****:*****@"{amount:500}"); streamWriter.Close(); } httpContext.Response.Close(); } finally { // Dispose Thread.Sleep(1000); httpListener?.Stop(); httpListener?.Close(); } })); }
public HTTPServer() { listener = new HttpListener(); listener.Prefixes.Add("http://*:" + WebAPI.dis.Configuration.Instance.Port + "/"); listener.Start(); WhitelistIPs = new List<string>() { }; if(WebAPI.dis.Configuration.Instance.WhitelistIPs.Count > 0) { foreach(var ip in WebAPI.dis.Configuration.Instance.WhitelistIPs) { WhitelistIPs.Add(ip.IP); } } AsyncCallback callback = null; callback = ar => { if (!listener.IsListening) return; new Thread(() => { this.ProcessClient( listener.EndGetContext(ar) ); }).Start(); listener.BeginGetContext(callback, null); }; listener.BeginGetContext(callback, null); }
public HTTPServer(int port) { string prefix = string.Format("http://{0}:{1}/", Settings.Default.AddressToListenOn, port); httpListener = new HttpListener(); httpListener.Prefixes.Add(prefix); }
/// <summary> /// Initializes new instance of <see cref="Server"/>. /// </summary> /// <param name="url">The url to host the server on.</param> /// <param name="resolver">The dependency resolver for the server.</param> public Server(string url, IDependencyResolver resolver) : base(resolver) { _url = url.Replace("*", @".*?"); _listener = new HttpListener(); _listener.Prefixes.Add(url); }
public void Start() { listener = new HttpListener(); string virtualDirectory = Configuration.VirtualDirectory; if (virtualDirectory.EndsWith("/") == false) virtualDirectory = virtualDirectory + "/"; listener.Prefixes.Add("http://+:" + Configuration.Port + virtualDirectory); switch (Configuration.AnonymousUserAccessMode) { case AnonymousUserAccessMode.None: listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication; break; case AnonymousUserAccessMode.All: break; case AnonymousUserAccessMode.Get: listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication | AuthenticationSchemes.Anonymous; listener.AuthenticationSchemeSelectorDelegate = request => { return request.HttpMethod == "GET" || request.HttpMethod == "HEAD" ? AuthenticationSchemes.Anonymous : AuthenticationSchemes.IntegratedWindowsAuthentication; }; break; default: throw new ArgumentException("Cannot understand access mode: " + Configuration.AnonymousUserAccessMode ); } listener.Start(); listener.BeginGetContext(GetContext, null); }
public void Run () { mainScheduler = TaskScheduler.FromCurrentSynchronizationContext (); Task.Run (() => { var url = "http://+:" + port + "/"; var remTries = 2; while (remTries > 0) { remTries--; listener = new HttpListener (); listener.Prefixes.Add (url); try { listener.Start (); remTries = 0; } catch (HttpListenerException ex) { if (remTries == 1 && ex.ErrorCode == 5) { // Access Denied GrantServerPermission (url); } else { throw; } } } Loop (); }); }
public void Start() { if (_isStarted) { return; } if (Port == 0) { throw new Exception("Порт не инициализирован"); } if (String.IsNullOrEmpty(Address)) { throw new Exception("Адрес не инициализирован"); } var prefix = String.Format("http://{0}:{1}/", Address, Port); _listener = new System.Net.HttpListener(); _listener.Prefixes.Add(prefix); _listener.Start(); for (int i = 0; i < MaxConnections; i++) { AddConnectionForListener(); } _isStarted = true; }
public void Httpserver() { System.Net.HttpListener lisener = null; try { lisener = new HttpListener(); lisener.Prefixes.Add("http://localhost:8080/simpleserver/"); lisener.Start(); while (true) { Console.WriteLine("Waiting.."); HttpListenerContext context = lisener.GetContext(); string msg = "hello world"; context.Response.ContentLength64 = Encoding.UTF8.GetByteCount(msg); context.Response.StatusCode = (int)HttpStatusCode.OK; using (Stream stream = context.Response.OutputStream) { using (StreamWriter writer = new StreamWriter(stream)) { writer.Write(msg); } } Console.WriteLine("Msg sent"); } } catch (WebException e) { Console.WriteLine(e.Status); } }
public void Start() { var listener = new System.Net.HttpListener(); listener.Prefixes.Add("http://localhost:1234/"); listener.Start(); var t = new Thread(_ => { while (true) { var context = listener.GetContext(); // get te context this.ExecutePipe(context); if (context.Request.HttpMethod == "GET") { _gets.GetOrIgnore(context.Request.Url.AbsolutePath)?.Invoke(context.Request, context.Response); } if (context.Request.HttpMethod == "POST") { _posts.GetOrIgnore(context.Request.Url.AbsolutePath)?.Invoke(context.Request, context.Response); } } }); t.Start(); }
/// <summary> /// Shut down the Web Service /// </summary> public virtual void Stop() { if (Listener == null) { return; } try { this.Listener.Close(); // remove Url Reservation if one was made if (registeredReservedUrl != null) { RemoveUrlReservationFromAcl(registeredReservedUrl); registeredReservedUrl = null; } } catch (HttpListenerException ex) { if (ex.ErrorCode != RequestThreadAbortedException) { throw; } Log.Error("Swallowing HttpListenerException({0}) Thread exit or aborted request".Fmt(RequestThreadAbortedException), ex); } this.IsStarted = false; this.Listener = null; }
/// <summary> /// Creates a listener wrapper that can be configured by the user before starting. /// </summary> internal OwinHttpListener() { _listener = new System.Net.HttpListener(); _startNextRequestAsync = new Action(ProcessRequestsAsync); _startNextRequestError = new Action <Task>(StartNextRequestError); SetRequestProcessingLimits(DefaultMaxAccepts, DefaultMaxRequests); }
static void HttpServer() { listener = new HttpListener(); listener.Prefixes.Add("http://*:5000/"); listener.Start(); while (true) { var context = listener.GetContext(); var request = context.Request; var response = context.Response; var tw = new StreamWriter(response.OutputStream); var path = request.Url.AbsolutePath; if (path.StartsWith("/type/")) { ShowInstancesOf(tw, path.Substring(6)); } else { Summary(tw); } tw.Flush(); response.OutputStream.Close(); } }
public void Start() { Task.Run(() => { _httpListener = new HttpListener(); _httpListener.Prefixes.Add(@"http://localhost:" +_portNumber +"/"); _httpListener.Start(); Console.WriteLine("The Http Transport Service has started..."); while (!IsStopped) { // Wait for the incoming request. HttpListenerContext context = _httpListener.GetContext(); HttpListenerRequest request = context.Request; // Obtain a response object. HttpListenerResponse response = context.Response; // Process the POST request to update the Employee object. if (request.HttpMethod == "POST") { UpdateEmployee(request, response); } } }); }
public void Stop() { if (_listener != null) { _listener.Stop (); _listener = null; } }
private async Task StartServer() { HttpServ = new HttpListener(); btnStartHttpServ.Text = "Stop Server"; HttpServ.Prefixes.Add("http://localhost:" + txtHttpPort.Value.ToString() + "/"); HttpServ.Start(); txtHttpLog.Text += "Start Listining on Port :" + txtHttpPort.Value + "\r\n"; txtHttpLog.Text += "Server is Running...\r\n\r\n"; while (true) { try { var ctx = await HttpServ.GetContextAsync(); txtHttpLog.Text += "Request: " + ctx.Request.Url.AbsoluteUri + "\r\n"; var page = Application.StartupPath + "\\wwwroot" + ctx.Request.Url.LocalPath; if (File.Exists(page)) { string file; var ext = new FileInfo(page); if (ext.Extension == ".php") { file = ProcessPhpPage(PhpCompilerPath, page); txtHttpLog.Text += "Processing php page...\r\n"; } else { file = File.ReadAllText(page); } await ctx.Response.OutputStream.WriteAsync(ASCIIEncoding.UTF8.GetBytes(file), 0, file.Length); ctx.Response.OutputStream.Close(); ctx.Response.Close(); txtHttpLog.Text += "Response: 200 OK\r\n\r\n"; } else { ctx.Response.StatusCode = 404; var file = "<h2 style=\"color:red;\">404 File Not Found !!!</h2>"; await ctx.Response.OutputStream.WriteAsync(ASCIIEncoding.UTF8.GetBytes(file), 0, file.Length); ctx.Response.OutputStream.Close(); ctx.Response.Close(); txtHttpLog.Text += "Response: 404 Not Found\r\n\r\n"; } } catch (Exception ex) { txtHttpLog.Text += "\r\nException: Server Stopped!!!\r\n\r\n"; // txtHttpLog.Text += "\r\nException: " + ex.Message + "\r\n\r\n"; break; } txtHttpLog.Select(0, 0); } }
public MyApi() { var httpListener = new System.Net.HttpListener(); httpListener.Prefixes.Add(MyEndPoint.Uri.ToString()); httpListener.Start(); }
static void Main(string[] args) { listener = new HttpListener(); listener.Prefixes.Add("http://*:" + port + "/"); //add IP of your website to link to gold purchase OR leave blank and create your own hard-coded website! listener.Start(); //Server will freak out if you don't have admin permissions listen = new Thread(ListenerCallback); listen.Start(); for (var i = 0; i < workers.Length; i++) { workers[i] = new Thread(Worker); workers[i].Start(); } Console.CancelKeyPress += (sender, e) => { Console.WriteLine("Terminating..."); listener.Stop(); while (contextQueue.Count > 0) Thread.Sleep(100); Environment.Exit(0); }; Console.ForegroundColor = ConsoleColor.Green; Console.Title = "Database Server"; Console.WriteLine("Connection Successful at Port " + port + "."); XmlDatas.behaviors = false; XmlDatas.DoSomething(); Thread.CurrentThread.Join(); }
public static void Main(string[] args) { if (!HttpListener.IsSupported) { Console.WriteLine ("HttpListener not available."); Environment.Exit (-1); } var bytecode = ProgramBytecode (); if (bytecode == null) { Environment.Exit (-1); } HttpListener hl = new HttpListener (); hl.Prefixes.Add ("http://localhost:8080/"); hl.Start (); var requestNo = 1; var fsd = new FileSystemDatabase ("db"); while (hl.IsListening) { var ctx = hl.GetContext (); Console.WriteLine ("Serving a request ({0} {1}).", requestNo, ctx.Request.Url.AbsolutePath); if (ctx.Request.Url.AbsolutePath == "/") { ServeGuessNumberRequest (ctx, fsd); } else { ctx.Response.OutputStream.Close (); } Console.WriteLine ("Served a request ({0}).", requestNo); requestNo++; } }
public static void AddTask(HttpListener listener) { var context = listener.GetContext(); tasks.Add(Task.Factory.StartNew( () => { var request = context.Request; var stream = request.InputStream; var query = request.Url.Query; var response = context.Response; if (requests.ContainsKey(query)) SendResponse(response, requests[query]); else { var regex = new Regex(@".query=."); lock (requests) { if (regex.IsMatch(query)) ProcessRequest(response, query); } } } )); }
/// <summary> /// Dispose(bool disposing) executes in two distinct scenarios. /// If disposing equals true, the method has been called directly /// or indirectly by a user's code. Managed and unmanaged resources /// can be disposed. /// If disposing equals false, the method has been called by the /// runtime from inside the finalizer and you should not reference /// other objects. Only unmanaged resources can be disposed. /// </summary> protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if (!this._disposed) { // Note disposing has been done. _disposed = true; // If disposing equals true, dispose all managed // and unmanaged resources. if (disposing) { // Dispose managed resources. if (_listener != null) { _listener.Close(); } } // Call the appropriate methods to clean up // unmanaged resources here. _listener = null; _queue = null; } }
private static void Main(string[] args) { var listener = new System.Net.HttpListener(); listener.Prefixes.Add("http://localhost:8080/"); listener.Prefixes.Add("http://127.0.0.1:8080/"); listener.Start(); while (true) { try { var context = listener.GetContext(); //Block until a connection comes in context.Response.StatusCode = 200; context.Response.SendChunked = true; var bytes = Encoding.UTF8.GetBytes("Hue Hue Hue\n"); context.Response.OutputStream.Write(bytes, 0, bytes.Length); context.Response.Close(); } catch (Exception) { // Client disconnected or some other error - ignored for this example } } }
public static async void ThreadProcAsync() { string uriPrefix = ConfigurationManager.AppSettings["ListenerPrefix"]; using (System.Net.HttpListener listener = new System.Net.HttpListener()) { listener.Prefixes.Add(uriPrefix); listener.IgnoreWriteExceptions = true; // For the sake of the development convenience, this code opens default web browser // with this server url when project is started in the debug mode as a console app. #if DEBUG if (!IsServiceMode) { System.Diagnostics.Process.Start(uriPrefix.Replace("+", "localhost"), null); } #endif listener.Start(); Console.WriteLine("Start listening on " + uriPrefix); Console.WriteLine("Press Control-C to stop listener..."); while (Listening) { HttpListenerContext context = await listener.GetContextAsync(); #pragma warning disable 4014 Task.Factory.StartNew(() => ProcessRequestAsync(listener, context)); #pragma warning restore 4014 } } }
public override void Run() { Trace.WriteLine("WorkerRole entry point called", "Information"); HttpListener listener = new HttpListener(); IPEndPoint inputEndPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["HelloWorldEndpoint"].IPEndpoint; string listenerPrefix = string.Format(CultureInfo.InvariantCulture, "http://{0}:{1}/", inputEndPoint.Address, inputEndPoint.Port); Trace.WriteLine("Listening to -" + listenerPrefix); listener.Prefixes.Add(listenerPrefix); listener.Start(); while (true) { // Note: The GetContext method blocks while waiting for a request. HttpListenerContext context = listener.GetContext(); // Obtain a response object. HttpListenerResponse response = context.Response; // Construct a response. string responseString = "<HTML><BODY> Hello world!</BODY></HTML>"; byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); // Get a response stream and write the response to it. response.ContentLength64 = buffer.Length; System.IO.Stream output = response.OutputStream; output.Write(buffer, 0, buffer.Length); //Close the output stream. output.Close(); } }
public AsyncServer(params string[] prefixes) { _listener = new HttpListener(); _listener.AuthenticationSchemes = AuthenticationSchemes.Anonymous; foreach (string s in prefixes) _listener.Prefixes.Add(s); Routes = new List<IRoute>() { new RouteMatchAction { MatchString = "time", MatchRule = RouteMatch.RouteMatchRule.Basic, Priority = int.MaxValue, ActionAsync = GetTime }, new RouteMatchAction { MatchString = "info", MatchRule = RouteMatch.RouteMatchRule.Basic, Priority = int.MaxValue, ActionAsync = GetInfo } }; }
public static void AssembyInitialize(TestContext testcontext) { listener = new HttpListener(); listener.Prefixes.Add("http://+:" + Port + WebSocketConstants.UriSuffix + "/"); listener.Start(); RunWebSocketServer().Fork(); }
public HttpCommunicationListener(string uriPrefix, string uriPublished, Func<HttpListenerContext, CancellationToken, Task> processRequest) { this.publishUri = uriPublished; this.processRequest = processRequest; this.httpListener = new HttpListener(); this.httpListener.Prefixes.Add(uriPrefix); }
static void Main(string[] args) { // Create a HTTP listener. HttpListener listener = new HttpListener(); listener.Prefixes.Add(MyEndpoint); listener.Start(); // will abort if port not permitted and not running in Administrator mode. try { ListenerLoop(listener); Console.Write(DateTime.UtcNow + ": Listening at"); foreach (string p in listener.Prefixes) Console.Write(" " + p); Console.WriteLine("\nPress any key to exit..."); Console.ReadKey(); } catch (Exception ex) { Console.WriteLine("Exception: Message:" + ex.Message); } finally { listener.Close(); } }
private static async void DispatchHttpRequestsAsync(System.Net.HttpListener httpListener, CancellationToken cancellationToken) { // Create a request handler factory that uses basic authentication var requestHandlerFactory = new RequestHandlerFactory(); // Create WebDAV dispatcher var homeFolder = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); var webDavDispatcher = new WebDavDispatcher(new DiskStore(homeFolder), requestHandlerFactory); // Determine the WebDAV username/password for authorization // (only when basic authentication is enabled) var webdavUsername = ConfigurationManager.AppSettings["webdav.username"] ?? "test"; var webdavPassword = ConfigurationManager.AppSettings["webdav.password"] ?? "test"; HttpListenerContext httpListenerContext; while (!cancellationToken.IsCancellationRequested && (httpListenerContext = await httpListener.GetContextAsync().ConfigureAwait(false)) != null) { // Determine the proper HTTP context IHttpContext httpContext; if (httpListenerContext.Request.IsAuthenticated) { httpContext = new HttpBasicContext(httpListenerContext, checkIdentity: i => i.Name == webdavUsername && i.Password == webdavPassword); } else { httpContext = new HttpContext(httpListenerContext); } // Dispatch the request await webDavDispatcher.DispatchRequestAsync(httpContext).ConfigureAwait(false); } }
public void BasicRoundTrip() { var serializer = new JsonCommonSerializer(); var server = new HttpListener(); server.Prefixes.Add("http://localhost:20000/"); server.Start(); var serverTransport = server.GenerateTransportSource(); var serverRouter = new DefaultMessageRouter(serverTransport, serializer); serverRouter.AddService<IMyService>(new MyService()); var client = new ClientWebSocket(); client.Options.SetBuffer(8192, 8192); var clientTransport = client.GenerateTransportSource(); var clientRouter = new DefaultMessageRouter(clientTransport, serializer); var proxy = clientRouter.AddInterface<IMyService>(); client.ConnectAsync(new Uri("ws://localhost:20000/"), CancellationToken.None).Wait(); var result = proxy.Add(3, 4).Result; Assert.Equal(7, result); clientRouter.Dispose(); clientTransport.Dispose(); client.Dispose(); serverRouter.Dispose(); serverTransport.Dispose(); server.Stop(); server.Close(); }
public void ShouldConfigure() { XmlConfigurator.Configure(); ILog logger = LogManager.GetLogger(typeof(HttpAppenderTests)); using (var listener = new HttpListener()) { listener.Prefixes.Add("http://localhost:34343/"); listener.AuthenticationSchemes = AuthenticationSchemes.Basic; listener.Start(); try { throw new Exception("KABOOM!"); } catch (Exception e) { logger.Error("Oh noes!", e); } var ctx = listener.GetContext(); using (var reader = new StreamReader(ctx.Request.InputStream)) { var body = reader.ReadToEnd(); Console.WriteLine(body); Assert.IsNotNull(body); HttpListenerBasicIdentity identity = (HttpListenerBasicIdentity)ctx.User.Identity; Assert.AreEqual("derp", identity.Name); Assert.AreEqual("darp", identity.Password); } ctx.Response.Close(); } }
public void Start() { logger = LoggerFactory.GetLogger("SimpleHttpServer.Server"); logger.Info("Server starting on port {0}", port); if (listener != null) { logger.Fatal("Server already started"); throw new InvalidOperationException("Already started"); } listener = new HttpListener(); listener.Prefixes.Add(string.Format("http://*:{0}/", port)); try { listener.Start(); } catch(Exception ex) { logger.Fatal("Error starting server", ex); throw; } logger.Info("Server started"); logger.Debug("Waiting for first request"); listener.BeginGetContext(ProcessRequest, null); }
public void GetContext2 () { HttpListener listener = new HttpListener (); listener.Start (); // "Please call AddPrefix () before calling this method" listener.GetContext (); }
private static void OpenFakeHttpServer(int port) { Console.WriteLine($"Openning port {port}"); int i = 0; var li = new HttpListener(); li.Prefixes.Add($"http://+:{port}/api/"); li.Start(); Task.Factory.StartNew(() => { while (true) { var ctx = li.GetContext(); using (ctx.Response) { ctx.Response.SendChunked = false; ctx.Response.StatusCode = 200; Console.WriteLine($"at {port} Correlation {ctx.Request.Headers["X-CORRELATION"]}"); using (var sw = new StreamWriter(ctx.Response.OutputStream)) { ++i; var str = $"{i}!!!"; ctx.Response.ContentLength64 = str.Length; sw.Write(str); } } } }); }
static int SelectNextAvailablePort() { var usedPorts = new List<int>(); var r = new Random(); int newPort; while (true) { using (var mListener = new HttpListener()) { newPort = r.Next(49152, 65535); if (usedPorts.Contains(newPort)) { continue; } mListener.Prefixes.Add(string.Format("http://localhost:{0}/", newPort)); try { mListener.Start(); } catch { continue; } } usedPorts.Add(newPort); break; } return newPort; }
public void Start() { _httpListener = new System.Net.HttpListener(); _httpListener.Prefixes.Add($"http://+:{_port}/"); _httpListener.Start(); }
/// <summary> /// 释放 /// </summary> public void Dispose() { if (listener != null) { listener.Stop(); listener = null; } }
/// <exclude /> public override void Open() { mHttpListener = new System.Net.HttpListener(); mHttpListener.Prefixes.Add(mUrl); mHttpListener.Start(); Task.Run(ListenAsync); }
public static void Main(string[] args) { var port = args.Length == 1 ? int.Parse(args [0]) : 8001; var listener = new System.Net.HttpListener(); // for Non Admin rights // netsh http add urlacl url=http://*:8001/api/Effect user=DOMAIN/user listener.Prefixes.Add(string.Format("http://*:{0}/api/Effect/", port)); listener.Start(); ThreadPool.QueueUserWorkItem((o) => { try { Console.WriteLine("Webserver running..."); while (listener.IsListening) { ThreadPool.QueueUserWorkItem((c) => { var ctx = c as HttpListenerContext; try { var contentLength = (int)ctx.Request.ContentLength64; var buffer = new byte[contentLength]; ctx.Request.InputStream.Read(buffer, 0, contentLength); var obj = Encoding.ASCII.GetString(buffer); var d = (Data)JsonConvert.DeserializeObject(obj, typeof(Data)); string error = String.Empty; byte[] buf = RunMGCB(d.Code, d.Platform, out error); var result = JsonConvert.SerializeObject(new Result() { Compiled = buf, Error = error }); ctx.Response.ContentLength64 = result.Length; ctx.Response.OutputStream.Write(Encoding.UTF8.GetBytes(result), 0, result.Length); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } // suppress any exceptions finally { // always close the stream ctx.Response.OutputStream.Close(); } }, listener.GetContext()); } } catch { } }); Console.Read(); listener.Stop(); listener.Close(); }
public void Stop() { if (Listener != null) { Listener.Close(); Listener = null; IsStarted = false; } }
/// <summary> /// Creates a listener wrapper that can be configured by the user before starting. /// </summary> internal OwinHttpListener() { _listener = new System.Net.HttpListener(); _startNextRequestAsync = new Action(StartNextRequestAsync); _startNextRequestError = new Func <CatchInfo, CatchInfoBase <Task> .CatchResult>(StartNextRequestError); _startProcessingRequest = new Action <HttpListenerContext>(StartProcessingRequest); _handleAcceptError = new Func <CatchInfo, CatchInfoBase <Task> .CatchResult>(HandleAcceptError); SetRequestProcessingLimits(DefaultMaxAccepts, DefaultMaxRequests); }
/// <summary> /// Starts the listener and request processing threads. /// </summary> internal void Start(System.Net.HttpListener listener, AppFunc appFunc, IList <IDictionary <string, object> > addresses, IDictionary <string, object> capabilities, LoggerFactoryFunc loggerFactory) { Contract.Assert(_appFunc == null); // Start should only be called once Contract.Assert(listener != null); Contract.Assert(appFunc != null); Contract.Assert(addresses != null); _listener = listener; _appFunc = appFunc; _loggerFactory = loggerFactory; if (_loggerFactory != null) { _logger = _loggerFactory(typeof(OwinHttpListener).FullName); } _basePaths = new List <string>(); foreach (var address in addresses) { // build url from parts string scheme = address.Get <string>("scheme") ?? Uri.UriSchemeHttp; string host = address.Get <string>("host") ?? "localhost"; string port = address.Get <string>("port") ?? "5000"; string path = address.Get <string>("path") ?? string.Empty; // if port is present, add delimiter to value before concatenation if (!string.IsNullOrWhiteSpace(port)) { port = ":" + port; } // Assume http(s)://+:9090/BasePath/, including the first path slash. May be empty. Must end with a slash. if (!path.EndsWith("/", StringComparison.Ordinal)) { // Http.Sys requires that the URL end in a slash path += "/"; } _basePaths.Add(path); // add a server for each url string url = scheme + "://" + host + port + path; _listener.Prefixes.Add(url); } _capabilities = capabilities; _disconnectHandler = new DisconnectHandler(_listener); if (!_listener.IsListening) { _listener.Start(); _disconnectHandler.Initialize(); } OffloadStartNextRequest(); }
private void connected(IAsyncResult result) { System.Net.HttpListener listener = (System.Net.HttpListener)result.AsyncState; HttpListenerContext context = listener.EndGetContext(result); requestedPath = context.Request.Url.AbsolutePath; context.Response.StatusCode = this.response; context.Response.OutputStream.Close(); }
public void Configure(string[] prefixes, string vdir, string pdir) { _virtualDir = vdir; _physicalDir = pdir; _listener = new System.Net.HttpListener(); foreach (string prefix in prefixes) { _listener.Prefixes.Add(prefix); } }
public void Stop() { if (!IsRunning) { return; } listener.Close(); listener.Abort(); listener = null; }
public void Start(string uriPrefix, Action <HttpListenerContext> sessionReceived) { _httpServer = new System.Net.HttpListener(); _httpServer.Prefixes.Add(uriPrefix); _httpServer.Start(); _running = true; _httpServer.BeginGetContext(HandleRequest, new SessionState(this, sessionReceived)); }
/// <summary> /// Start the http listener. /// </summary> public async void Start() { // If not running. if (!_running) { try { // Create a new http listener if (_listener == null) { _listener = new System.Net.HttpListener(); // Add URI prefixes to listen for. foreach (string uri in _uriList) { _listener.Prefixes.Add(uri); } } // Set the Authentication Schemes. _listener.AuthenticationSchemes = _authenticationSchemes; if (_authenticationSchemeSelectorDelegate != null) { _listener.AuthenticationSchemeSelectorDelegate = _authenticationSchemeSelectorDelegate; } // Start the listener _listener.Start(); _running = true; // Keep the service in the running start // listen for in-comming requests. while (_running) { // Wait for the next request. HttpListenerContext listenerContext = await _listener.GetContextAsync(); // Send the http context to the handler. if (listenerContext != null) { AsynchronousListener(listenerContext); } } } catch (Exception) { if (_listener != null) { _listener.Close(); } throw; } } }
public virtual void Start() { try { _listener = new System.Net.HttpListener(); _listener.Prefixes.Add(string.Format("http://+:{0}/{1}", Port, Prefix)); _listener.Start(); _listener.BeginGetContext(this.Listener_Request, _listener); } catch (Exception ex) { TraceLogger.Instance.WriteException(ex); throw; } }
protected void Start(IEnumerable <string> urlBases, WaitCallback listenCallback) { // *** Already running - just leave it in place if (this.IsStarted) { return; } if (this.Listener == null) { Listener = CreateHttpListener(); } foreach (var urlBase in urlBases) { if (HostContext.Config.HandlerFactoryPath == null) { HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(urlBase); } Listener.Prefixes.Add(urlBase); } try { Listener.Start(); IsStarted = true; } catch (HttpListenerException ex) { if (Config.AllowAclUrlReservation && ex.ErrorCode == 5 && registeredReservedUrl == null) { foreach (var urlBase in urlBases) { registeredReservedUrl = AddUrlReservationToAcl(urlBase); if (registeredReservedUrl == null) { break; } } if (registeredReservedUrl != null) { Listener = null; Start(urlBases, listenCallback); return; } } throw ex; } ThreadPool.QueueUserWorkItem(listenCallback); }
/// <summary> /// Starts listening for incoming connections /// </summary> public override void Start() { if (Running) { return; } listener = new System.Net.HttpListener(); listener.Prefixes.Add(prefix); listener.Start(); listener.BeginGetContext(EndGetRequest, listener); }
public void Listen() { if (!HttpListener.IsSupported) { throw new System.InvalidOperationException( "使用 HttpListener 必须为 Windows XP SP2 或 Server 2003 以上系统!"); } string[] prefixes = new string[] { host }; listener = new HttpListener(); foreach (string s in prefixes) { listener.Prefixes.Add(s); } listener.Start(); while (is_active) { HttpListenerContext context = listener.GetContext(); HttpListenerRequest request = context.Request; Console.WriteLine("{0} {1} HTTP/1.1", request.HttpMethod, request.RawUrl); Console.WriteLine("User-Agent: {0}", request.UserAgent); Console.WriteLine("Accept-Encoding: {0}", request.Headers["Accept-Encoding"]); Console.WriteLine("Connection: {0}", request.KeepAlive ? "Keep-Alive" : "close"); Console.WriteLine("Host: {0}", request.UserHostName); HttpListenerResponse response = context.Response; if (request.HttpMethod == "GET") { OnGetRequest(request, response); } else { OnPostRequest(request, response); } } }
private static void Main() { var listener = new HttpListener(); const string host = "http://192.168.1.42:9001/"; listener.Prefixes.Add(host); listener.Start(); Console.WriteLine("Listening on {0}...", host); new Thread(() => { Console.ReadLine(); Environment.Exit(0); }).Start(); while (true) { var context = listener.GetContext(); var response = context.Response; var request = context.Request; var query = request.QueryString["q"]; Console.WriteLine("{0} - {1}", DateTime.Now, query); var res = ""; if (query != null) { if (Regex.IsMatch(query, "Share")) res = "Point"; } var buffer = Encoding.UTF8.GetBytes(res); response.ContentLength64 = buffer.Length; var output = response.OutputStream; output.Write(buffer, 0, buffer.Length); output.Close(); } }