private static async void StartAsync()
{
_httpListener = await Initializer.GetHttpListener(_deviceLocalIp);
await StartDeviceListening();
await StartSendingRandomNotify();
}
public Server(
IHttpListener listener,
IEndpointProvider endpointProvider,
IOutput output,
ISoapDecoder soapDecoder,
ILogger logger,
IContentTypeProvider contentTypeProvider,
IWebRequestFactory webRequestFactory)
{
this.listener = listener;
this.endpointProvider = endpointProvider;
this.output = output;
this.soapDecoder = soapDecoder;
this.logger = logger;
this.contentTypeProvider = contentTypeProvider;
this.webRequestFactory = webRequestFactory;
try
{
listener.Prefixes.Add(endpointProvider.ServerBaseUrl);
}
catch (ArgumentException ex)
{
throw new FailException(
string.Format(
"While attempting to listen on URL '{1}': {0}",
ex.Message,
endpointProvider.ServerBaseUrl),
ex);
}
logger.Info("Listening on: {0}", endpointProvider.ServerBaseUrl);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebDAVServer"/> class.
/// </summary>
/// <param name="store">
/// The <see cref="IWebDAVStore"/> store object that will provide
/// collections and documents for this <see cref="WebDAVServer"/>.
/// </param>
/// <param name="logger">
/// The <see cref="ILogger"/> object that log messages will be sent to;
/// or <c>null</c> to not use a logger.
/// </param>
/// <param name="listener">
/// The <see cref="IHttpListener"/> object that will handle the web server portion of
/// the WebDAV server; or <c>null</c> to use a fresh one.
/// </param>
/// <param name="methodHandlers">
/// A collection of HTTP method handlers to use by this <see cref="WebDAVServer"/>;
/// or <c>null</c> to use the built-in method handlers.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="listener"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="store"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para><paramref name="methodHandlers"/> is empty.</para>
/// <para>- or -</para>
/// <para><paramref name="methodHandlers"/> contains a <c>null</c>-reference.</para>
/// </exception>
public WebDAVServer(IWebDAVStore store, ILogger logger = null, IHttpListener listener = null, IEnumerable <IWebDAVMethodHandler> methodHandlers = null)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (listener == null)
{
listener = new HttpListenerAdapter();
_OwnsListener = true;
}
methodHandlers = methodHandlers ?? WebDAVMethodHandlers.BuiltIn;
if (!methodHandlers.Any())
{
throw new ArgumentException("The methodHandlers collection is empty", "methodHandlers");
}
if (methodHandlers.Any(methodHandler => methodHandler == null))
{
throw new ArgumentException("The methodHandlers collection contains a null-reference", "methodHandlers");
}
_Listener = listener;
_Store = store;
var handlersWithNames =
from methodHandler in methodHandlers
from name in methodHandler.Names
select new { name, methodHandler };
_MethodHandlers = handlersWithNames.ToDictionary(v => v.name, v => v.methodHandler);
_Logger = logger ?? new VoidLogger();
}
/// <summary>
/// Start listening
/// </summary>
/// <param name="host"></param>
/// <param name="port"></param>
/// <param name="listenCallback"></param>
public void Listen(string host, int port, Action listenCallback = null)
{
if (!HttpListener.IsSupported)
{
Console.WriteLine("Windows XP SP2 or Server 2003 is required to use the HttpListener class.");
return;
}
// Create a listener.
_listener = _container.GetInstance <IHttpListener>();
var hostPrefix = CreatePrefix(host, port);
_listener.Prefixes.Add(hostPrefix);
IsListening = true;
_listener.Start();
_httpThread.Start();
_httpThread.IsBackground = true;
if (listenCallback != null)
{
listenCallback();
}
}
public HttpListenerHost(
IServerApplicationHost applicationHost,
ILogger <HttpListenerHost> logger,
IServerConfigurationManager config,
IConfiguration configuration,
INetworkManager networkManager,
IJsonSerializer jsonSerializer,
IXmlSerializer xmlSerializer,
IHttpListener socketListener,
ILocalizationManager localizationManager,
ServiceController serviceController,
IHostEnvironment hostEnvironment)
{
_appHost = applicationHost;
_logger = logger;
_config = config;
_defaultRedirectPath = configuration[DefaultRedirectKey];
_baseUrlPrefix = _config.Configuration.BaseUrl;
_networkManager = networkManager;
_jsonSerializer = jsonSerializer;
_xmlSerializer = xmlSerializer;
_socketListener = socketListener;
ServiceController = serviceController;
_socketListener.WebSocketConnected = OnWebSocketConnected;
_hostEnvironment = hostEnvironment;
_funcParseFn = t => s => JsvReader.GetParseFn(t)(s);
Instance = this;
ResponseFilters = Array.Empty <Action <IRequest, HttpResponse, object> >();
GlobalResponse = localizationManager.GetLocalizedString("StartupEmbyServerIsLoading");
}
/// <summary>
/// Initializes a new instance of the <see cref="WebServer" /> class.
/// </summary>
/// <param name="urlPrefixes">The URL prefix.</param>
/// <param name="routingStrategy">The routing strategy.</param>
/// <param name="httpListener">The HTTP listener.</param>
/// <exception cref="ArgumentException">Argument urlPrefix must be specified.</exception>
/// <remarks>
/// <c>urlPrefixes</c> must be specified as something similar to: http://localhost:9696/
/// Please notice the ending slash. -- It is important.
/// </remarks>
public WebServer(string[] urlPrefixes, RoutingStrategy routingStrategy, IHttpListener httpListener)
{
if (urlPrefixes == null || urlPrefixes.Length <= 0)
{
throw new ArgumentException("At least 1 URL prefix in urlPrefixes must be specified");
}
$"Running HTTPListener: {httpListener.Name}".Info(nameof(WebServer));
RoutingStrategy = routingStrategy;
if (RoutingStrategy == RoutingStrategy.Wildcard)
{
"Wilcard routing will be dropped in the next major version of EmbedIO. We advise to use Regex only".Debug(nameof(WebServer));
}
Listener = httpListener;
foreach (var prefix in urlPrefixes)
{
var urlPrefix = new string(prefix?.ToCharArray());
if (urlPrefix.EndsWith("/") == false)
{
urlPrefix = urlPrefix + "/";
}
urlPrefix = urlPrefix.ToLowerInvariant();
Listener.AddPrefix(urlPrefix);
$"Web server prefix '{urlPrefix}' added.".Info(nameof(WebServer));
}
"Finished Loading Web Server.".Info(nameof(WebServer));
}
public OAuthCallbackListener(IHttpListener httpListener)
{
Guard.ArgumentNotNull(httpListener, nameof(httpListener));
this.httpListener = httpListener;
httpListener.Prefixes.Add(CallbackUrl);
}
public void DoesNotCallCloseOnListenerWhenListenerIsNull()
{
IHttpListener listener = null;
var server = new RestServer(listener);
Should.NotThrow(() => server.Dispose());
}
public void SetUp()
{
_Logger = Isolate.Fake.Instance <ILogger>();
_Store = Isolate.Fake.Instance <IWebDAVStore>();
_Listener = Isolate.Fake.Instance <IHttpListener>();
_MethodHandlers = WebDAVMethodHandlers.BuiltIn.ToList();
}
public RestServer(IServerSettings options)
{
Listener = new Interfaces.Server.HttpListener(new Mono.Net.HttpListener());
Listening = new Thread(HandleRequests);
StopEvent = new ManualResetEvent(false);
options.CloneEventHandlers(this);
Host = options.Host;
Port = options.Port;
PublicFolders = options.PublicFolders;
Router = options.Router;
Logger = options.Logger;
UseHttps = options.UseHttps;
_dependencyResolver = options.DependencyResolver;
/* Obsolete */
Connections = options.Connections;
OnBeforeStart = options.OnBeforeStart;
OnAfterStart = options.OnAfterStart;
OnBeforeStop = options.OnBeforeStop;
OnAfterStop = options.OnAfterStop;
Advanced = new AdvancedRestServer(Listener);
Listener.IgnoreWriteExceptions = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebServer" /> class.
/// </summary>
/// <param name="urlPrefixes">The URL prefix.</param>
/// <param name="routingStrategy">The routing strategy.</param>
/// <param name="httpListener">The HTTP listener.</param>
/// <exception cref="ArgumentException">Argument urlPrefix must be specified.</exception>
/// <remarks>
/// <c>urlPrefixes</c> must be specified as something similar to: http://localhost:9696/
/// Please notice the ending slash. -- It is important.
/// </remarks>
public WebServer(string[] urlPrefixes, RoutingStrategy routingStrategy, IHttpListener httpListener)
{
if (urlPrefixes == null || urlPrefixes.Length <= 0)
{
throw new ArgumentException("At least 1 URL prefix in urlPrefixes must be specified");
}
$"Running HTTPListener: {httpListener.Name}".Info(nameof(WebServer));
RoutingStrategy = routingStrategy;
Listener = httpListener;
foreach (var prefix in urlPrefixes)
{
var urlPrefix = new string(prefix?.ToCharArray());
if (urlPrefix.EndsWith("/") == false)
{
urlPrefix = urlPrefix + "/";
}
urlPrefix = urlPrefix.ToLowerInvariant();
Listener.AddPrefix(urlPrefix);
$"Web server prefix '{urlPrefix}' added.".Info(nameof(WebServer));
}
"Finished Loading Web Server.".Info(nameof(WebServer));
}
public ServiceController(ILog log, IScheduler scheduler, IFileSystemWatcher watcher, IHttpListener listener)
{
_log = log;
_scheduler = scheduler;
_watcher = watcher;
_httpListener = listener;
}
public HttpServer(IHttpHandler app, HttpServerSettings settings)
{
if (app == null) throw new ArgumentNullException("app");
if (settings == null) throw new ArgumentNullException("settings");
// init asp.net host
if (settings.AspNetHost)
{
var appHost = new AppHost(settings);
appHost.Init();
}
IHttpListener listener;
switch (settings.Mode)
{
case HttpServerMode.TcpListener:
listener = new TcpListenerImpl(app, settings);
break;
case HttpServerMode.HttpListener:
listener = new HttpListenerImpl(app, settings);
break;
default:
throw new ArgumentOutOfRangeException();
}
_listener = listener;
_listener.Start();
_listenerThread = new Thread(Listen);
_listenerThread.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="WebDavServer" /> class.
/// </summary>
/// <param name="store">The
/// <see cref="IWebDavStore" /> store object that will provide
/// collections and documents for this
/// <see cref="WebDavServer" />.</param>
/// <param name="listener">The
/// <see cref="IHttpListener" /> object that will handle the web server portion of
/// the WebDAV server; or
/// <c>null</c> to use a fresh one.</param>
/// <param name="methodHandlers">A collection of HTTP method handlers to use by this
/// <see cref="WebDavServer" />;
/// or
/// <c>null</c> to use the built-in method handlers.</param>
/// <exception cref="System.ArgumentNullException"><para>
/// <paramref name="listener" /> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="store" /> is <c>null</c>.</para></exception>
/// <exception cref="System.ArgumentException"><para>
/// <paramref name="methodHandlers" /> is empty.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="methodHandlers" /> contains a <c>null</c>-reference.</para></exception>
public WebDavServer(IWebDavStore store, IHttpListener listener = null, IEnumerable<IWebDavMethodHandler> methodHandlers = null)
{
if (store == null)
throw new ArgumentNullException("store");
if (listener == null)
{
listener = new HttpListenerAdapter();
_ownsListener = true;
}
methodHandlers = methodHandlers ?? WebDavMethodHandlers.BuiltIn;
IWebDavMethodHandler[] webDavMethodHandlers = methodHandlers as IWebDavMethodHandler[] ?? methodHandlers.ToArray();
if (!webDavMethodHandlers.Any())
throw new ArgumentException("The methodHandlers collection is empty", "methodHandlers");
if (webDavMethodHandlers.Any(methodHandler => methodHandler == null))
throw new ArgumentException("The methodHandlers collection contains a null-reference", "methodHandlers");
_listener = listener;
_store = store;
var handlersWithNames =
from methodHandler in webDavMethodHandlers
from name in methodHandler.Names
select new
{
name,
methodHandler
};
_methodHandlers = handlersWithNames.ToDictionary(v => v.name, v => v.methodHandler);
_log = LogManager.GetCurrentClassLogger();
}
public HttpListenerHost(
IServerApplicationHost applicationHost,
ILogger <HttpListenerHost> logger,
IServerConfigurationManager config,
IConfiguration configuration,
INetworkManager networkManager,
IJsonSerializer jsonSerializer,
IXmlSerializer xmlSerializer,
IHttpListener socketListener)
{
_appHost = applicationHost;
_logger = logger;
_config = config;
_defaultRedirectPath = configuration["HttpListenerHost:DefaultRedirectPath"];
_baseUrlPrefix = _config.Configuration.BaseUrl;
_networkManager = networkManager;
_jsonSerializer = jsonSerializer;
_xmlSerializer = xmlSerializer;
_socketListener = socketListener;
_socketListener.WebSocketConnected = OnWebSocketConnected;
_funcParseFn = t => s => JsvReader.GetParseFn(t)(s);
Instance = this;
ResponseFilters = Array.Empty <Action <IRequest, HttpResponse, object> >();
}
/// <summary>
/// </summary>
/// <param name="name"></param>
/// <param name="listener"></param>
/// <param name="handlers"></param>
/// <param name="store"></param>
/// <param name="server"></param>
public HttpReciever(string name, ref IHttpListener listener, ref Dictionary<string, IWebDavMethodHandler> handlers, ref IWebDavStore store, WebDavServer server)
{
_listener = listener;
_methodHandlers = handlers;
_store = store;
_server = server;
_name = name;
}
private static async void StartAsync()
{
_httpListener = await Initializer.GetHttpListener(_controlPointLocalIp);
//StartDeviceListening();
await StartControlPointListeningAsync();
}
public void AddListener(IHttpListener listener)
{
if (listening)
{
throw new InvalidOperationException("Cannot modify listeners without ");
}
listeners.Add(listener);
}
/// <summary>
/// Add a HTTP listener.
/// </summary>
/// <param name="listener"></param>
/// <exception cref="InvalidOperationException">Listener have been started.</exception>
public void Add(IHttpListener listener)
{
if (listener.IsStarted)
{
throw new InvalidOperationException("Listener have been started.");
}
_listeners.Add(listener);
}
public void ReturnsFalseWhenListenerIsNull()
{
IHttpListener listener = null;
using (var server = new RestServer(listener))
{
server.IsListening.ShouldBeFalse();
}
}
public Proxy(IHttpListenerFactory listenerFactory, IWebRequestFactory webRequestFactory,
IEnumerable <string> prefixes, AuthenticationSchemes authenticationSchemes)
{
_requestFilters = new List <IWebRequestFilter>();
_responseFilters = new List <IWebResponseFilter>();
_requestProcessor = new ProxyRequestProcessor(webRequestFactory);
_listener = listenerFactory.CreateListener(prefixes, authenticationSchemes);
_listener.Request += ListenerRequest;
}
public ObsidianSQL(string[] prefixes, IConnectionManager connectionManager)
{
ConfigureLogger();
_router = new Router();
_httpListener = new HttpListener();
_requestListener = new RequestListener(_httpListener, prefixes, _router);
_loginController = new LoginController(connectionManager);
_dbController = new DatabaseController(connectionManager);
_tableController = new TableController(connectionManager);
ConfigureRouter();
}
public void StartServer(string[] urlPrefixes, IHttpListener httpListener)
{
UrlPrefixes = urlPrefixes;
_listener = httpListener;
_listener.WebSocketConnected = OnWebSocketConnected;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
/// <summary>
/// Starts the Web Service
/// </summary>
private void StartListener()
{
HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(UrlPrefixes.First());
_listener = GetListener();
_listener.WebSocketHandler = WebSocketHandler;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
public void Start()
{
_isActive = true;
foreach (var listener in _listeners)
{
IHttpListener tempListener = listener;
Task.Factory.StartNew(() => Listen(tempListener));
}
Log.Information("Embedded uhttpserver started.");
}
/// <summary>
/// Starts the Web Service
/// </summary>
private void StartListener()
{
WebSocketSharpRequest.HandlerFactoryPath = GetHandlerPathIfAny(UrlPrefixes.First());
_listener = GetListener();
_listener.WebSocketConnected = OnWebSocketConnected;
_listener.WebSocketConnecting = OnWebSocketConnecting;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
public RequestListener(IHttpListener httpListener, string[] prefixes, IRouter router)
{
_router = router;
_httpListener = httpListener;
//Add prefixes to HttpListener
prefixes.ToList().ForEach(prefix => _httpListener.AddPrefix(prefix));
//Start Listener
_httpListener.Start();
Log.Information("HttpListener started");
}
public void StartServer(string[] urlPrefixes)
{
UrlPrefixes = urlPrefixes;
_listener = GetListener();
_listener.WebSocketConnected = OnWebSocketConnected;
_listener.WebSocketConnecting = OnWebSocketConnecting;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
public SslListener(IHttpListener child, X509Certificate certificate)
{
_child = child;
#if NETCOREAPP2_1 || NETSTANDARD2_1
_auth = new SslServerAuthenticationOptions()
{
ServerCertificate = new X509Certificate2(certificate.Export(X509ContentType.Pkcs12)),
ClientCertificateRequired = false,
EnabledSslProtocols = SslProtocols.Tls12
};
#else
_certificate = new X509Certificate2(certificate.Export(X509ContentType.Pkcs12));
#endif
}
/// <summary>
/// Starts the Web Service
/// </summary>
private void StartListener()
{
HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(UrlPrefixes.First());
_listener = NativeWebSocket.IsSupported
? _listener = new WebSocketSharpListener(_logger)
: _listener = new WebSocketSharpListener(_logger);
_listener.WebSocketHandler = WebSocketHandler;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="authtype"></param>
/// <param name="methodHandlers"></param>
public WebDavServer(IWebDavStore store, AuthType authtype, IEnumerable <IWebDavMethodHandler> methodHandlers = null)
{
_ownsListener = true;
switch (authtype)
{
case AuthType.Basic:
_listener = new HttpListenerBasicAdapter();
break;
case AuthType.Negotiate:
_listener = new HttpListenerNegotiateAdapter();
break;
case AuthType.Anonymous:
_listener = new HttpListenerAnyonymousAdapter();
break;
case AuthType.Smart:
_listener = new HttpListenerSmartAdapter();
break;
}
methodHandlers = methodHandlers ?? WebDavMethodHandlers.BuiltIn;
IWebDavMethodHandler[] webDavMethodHandlers = methodHandlers as IWebDavMethodHandler[] ?? methodHandlers.ToArray();
if (!webDavMethodHandlers.Any())
{
throw new ArgumentException("The methodHandlers collection is empty", "methodHandlers");
}
if (webDavMethodHandlers.Any(methodHandler => methodHandler == null))
{
throw new ArgumentException("The methodHandlers collection contains a null-reference", "methodHandlers");
}
//_negotiateListener = listener;
_store = store;
var handlersWithNames =
from methodHandler in webDavMethodHandlers
from name in methodHandler.Names
select new
{
name,
methodHandler
};
_methodHandlers = handlersWithNames.ToDictionary(v => v.name, v => v.methodHandler);
UpdateDavHeader();
}
private async void Listen(IHttpListener listener)
{
var aggregatedHandler = _handlers.Aggregate();
while (_isActive)
{
try {
new HttpClientHandler(await listener.GetClient().ConfigureAwait(false), aggregatedHandler, _requestProvider, _logger);
} catch (Exception e) {
_logger?.Warn($"Error while getting client", e);
}
}
_logger?.Info("Embedded uhttpserver stopped.");
}
public RestFulServer(IRestFulSettings settings, IRestFulLogger logger, ISerializer serializer,
IHttpListener httpListener, IRouter router)
{
_uriBuilder = new UriBuilder
{
Host = settings.Host,
Port = settings.Port,
Scheme = (settings.UseHTTPs) ? "https" : "http"
};
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_httpListener = httpListener ?? throw new ArgumentNullException(nameof(httpListener));
_router = router ?? throw new ArgumentNullException(nameof(router));
}
private async void Listen(IHttpListener listener)
{
while (_isActive)
{
try
{
new HttpClient(await listener.GetClient().ConfigureAwait(false), _handlers, _requestProvider);
}
catch (Exception e)
{
Logger.Warn("Error while getting client", e);
}
}
Logger.InfoFormat("Embedded uhttpserver stopped.");
}
public RestServer(IServerSettings options)
{
Listener = new HttpListener(new System.Net.HttpListener());
Listening = new Thread(HandleRequests);
StopEvent = new ManualResetEvent(false);
options.CloneEventHandlers(this);
Host = options.Host;
Logger = options.Logger;
Port = options.Port;
PublicFolders = options.PublicFolders;
Router = options.Router;
UseHttps = options.UseHttps;
Advanced = new AdvancedRestServer(Listener);
Listener.IgnoreWriteExceptions = true;
}
/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="authtype"></param>
/// <param name="methodHandlers"></param>
public WebDavServer(IWebDavStore store, AuthType authtype, IEnumerable<IWebDavMethodHandler> methodHandlers = null)
{
_ownsListener = true;
switch (authtype)
{
case AuthType.Basic:
_listener = new HttpListenerBasicAdapter();
break;
case AuthType.Negotiate:
_listener = new HttpListenerNegotiateAdapter();
break;
case AuthType.Anonymous:
_listener = new HttpListenerAnyonymousAdapter();
break;
case AuthType.Smart:
_listener = new HttpListenerSmartAdapter();
break;
}
methodHandlers = methodHandlers ?? WebDavMethodHandlers.BuiltIn;
IWebDavMethodHandler[] webDavMethodHandlers = methodHandlers as IWebDavMethodHandler[] ?? methodHandlers.ToArray();
if (!webDavMethodHandlers.Any())
throw new ArgumentException("The methodHandlers collection is empty", "methodHandlers");
if (webDavMethodHandlers.Any(methodHandler => methodHandler == null))
throw new ArgumentException("The methodHandlers collection contains a null-reference", "methodHandlers");
//_negotiateListener = listener;
_store = store;
var handlersWithNames =
from methodHandler in webDavMethodHandlers
from name in methodHandler.Names
select new
{
name,
methodHandler
};
_methodHandlers = handlersWithNames.ToDictionary(v => v.name, v => v.methodHandler);
UpdateDavHeader();
}
void OnAfterRegister(IHttpListener listner)
{
var methods = listner.GetType().GetMethods();
var type = listner.GetType();
foreach (var m in methods)
{
if (m.DeclaringType != type)
continue;
try
{
AddEvent(listner, m);
}
catch (Exception e)
{
e.Handle();
}
}
}
void OnAfterUnRegister(IHttpListener listner)
{
var type = listner.GetType();
var methods = listner.GetType().GetMethods();
foreach (var m in methods)
{
if (m.DeclaringType != type)
continue;
RemoveEvent(listner, m);
}
}
/// <summary>
/// Starts the Web Service
/// </summary>
private void StartListener()
{
HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(UrlPrefixes.First());
_listener = GetListener();
_listener.WebSocketConnected = OnWebSocketConnected;
_listener.WebSocketConnecting = OnWebSocketConnecting;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
/// <summary>
/// Starts the Web Service
/// </summary>
private void StartListener()
{
HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(UrlPrefixes.First());
_listener = NativeWebSocket.IsSupported
? _listener = new WebSocketSharpListener(_logger)
: _listener = new WebSocketSharpListener(_logger);
_listener.WebSocketHandler = WebSocketHandler;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
_listener.Start(UrlPrefixes);
}
private void RemoveEvent(IHttpListener listner, MethodInfo m)
{
switch (m.Name)
{
case "OnAcquireRequestState":
context.AcquireRequestState -= listner.OnAcquireRequestState;
break;
case "OnAuthenticateRequest":
context.AuthenticateRequest -= listner.OnAuthenticateRequest;
break;
case "OnAuthorizeRequest":
context.AuthorizeRequest -= listner.OnAuthorizeRequest;
break;
case "OnBeginRequest":
context.BeginRequest -= listner.OnBeginRequest;
break;
case "OnDisposed":
context.Disposed -= listner.OnDisposed;
break;
case "OnEndRequest":
context.EndRequest -= listner.OnEndRequest;
break;
case "OnError":
context.Error -= listner.OnError;
break;
case "OnLogRequest":
context.LogRequest -= listner.OnLogRequest;
break;
case "OnMapRequestHandler":
context.MapRequestHandler -= listner.OnMapRequestHandler;
break;
case "OnPostAcquireRequestState":
context.PostAcquireRequestState -= listner.OnPostAcquireRequestState;
break;
case "OnPostAuthenticateRequest":
context.PostAuthenticateRequest -= listner.OnPostAuthenticateRequest;
break;
case "OnPostAuthorizeRequest":
context.PostAuthorizeRequest -= listner.OnPostAuthorizeRequest;
break;
case "OnPostLogRequest":
context.PostLogRequest -= listner.OnPostLogRequest;
break;
case "OnPostMapRequestHandler":
context.PostMapRequestHandler -= listner.OnPostMapRequestHandler;
break;
case "OnPostReleaseRequestState":
context.PostReleaseRequestState -= listner.OnPostReleaseRequestState;
break;
case "OnPostRequestHandlerExecute":
context.PostRequestHandlerExecute -= listner.OnPostRequestHandlerExecute;
break;
case "OnPostResolveRequestCache":
context.PostResolveRequestCache -= listner.OnPostResolveRequestCache;
break;
case "OnPostUpdateRequestCache":
context.PostUpdateRequestCache -= listner.OnPostUpdateRequestCache;
break;
case "OnPreRequestHandlerExecute":
context.PreRequestHandlerExecute -= listner.OnPreRequestHandlerExecute;
break;
case "OnPreSendRequestContent":
context.PreSendRequestContent -= listner.OnPreSendRequestContent;
break;
case "OnPreSendRequestHeaders":
context.PreSendRequestHeaders -= listner.OnPreSendRequestHeaders;
break;
case "OnReleaseRequestState":
context.ReleaseRequestState -= listner.OnReleaseRequestState;
break;
case "OnResolveRequestCache":
context.ResolveRequestCache -= listner.OnResolveRequestCache;
break;
case "OnUpdateRequestCache":
context.UpdateRequestCache -= listner.OnUpdateRequestCache;
break;
}
}
public void Unregister(IHttpListener item)
{
if (Items.Contains(item))
{
Items.Remove(item);
OnAfterUnRegister(item);
}
}
public void Register(IHttpListener item)
{
if (!Items.Contains(item))
{
Items.Add(item);
OnAfterRegister(item);
}
}
/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="authtype"></param>
/// <param name="methodHandlers"></param>
public WebDavServer(IWebDavStore store, AuthType authtype, IEnumerable<IWebDavMethodHandler> methodHandlers = null)
{
_ownsListener = true;
switch (authtype)
{
case AuthType.Basic:
_listener = new HttpListenerBasicAdapter();
break;
case AuthType.Negotiate:
_listener = new HttpListenerNegotiateAdapter();
break;
case AuthType.Anonymous:
_listener = new HttpListenerAnyonymousAdapter();
break;
}
//_negotiateListener = listener;
_store = store;
_webDavRequestProcessor = new WebDavRequestProcessor(store, methodHandlers);
}
/// <summary>
/// This constructor uses a Negotiate Listener if one isn't passed.
///
/// Initializes a new instance of the <see cref="WebDavServer" /> class.
/// </summary>
/// <param name="store">The
/// <see cref="IWebDavStore" /> store object that will provide
/// collections and documents for this
/// <see cref="WebDavServer" />.</param>
/// <param name="listener">The
/// <see cref="IHttpListener" /> object that will handle the web server portion of
/// the WebDAV server; or
/// <c>null</c> to use a fresh one.</param>
/// <param name="methodHandlers">A collection of HTTP method handlers to use by this
/// <see cref="WebDavServer" />;
/// or
/// <c>null</c> to use the built-in method handlers.</param>
/// <exception cref="System.ArgumentNullException"><para>
/// <paramref name="listener" /> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="store" /> is <c>null</c>.</para></exception>
/// <exception cref="System.ArgumentException"><para>
/// <paramref name="methodHandlers" /> is empty.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="methodHandlers" /> contains a <c>null</c>-reference.</para></exception>
public WebDavServer(IWebDavStore store, IHttpListener listener = null, IEnumerable<IWebDavMethodHandler> methodHandlers = null)
{
if (store == null)
throw new ArgumentNullException("store");
if (listener == null)
{
listener = new HttpListenerNegotiateAdapter();
_ownsListener = true;
}
_listener = listener;
_store = store;
_webDavRequestProcessor = new WebDavRequestProcessor(store, methodHandlers);
}
/// <summary>
/// This constructor uses a Negotiate Listener if one isn't passed.
/// Initializes a new instance of the <see cref="WebDavServer" /> class.
/// </summary>
/// <param name="store">
/// The
/// <see cref="IWebDavStore" /> store object that will provide
/// collections and documents for this
/// <see cref="WebDavServer" />.
/// </param>
/// <param name="listener">
/// The
/// <see cref="IHttpListener" /> object that will handle the web server portion of
/// the WebDAV server; or
/// <c>null</c> to use a fresh one.
/// </param>
/// <param name="methodHandlers">
/// A collection of HTTP method handlers to use by this
/// <see cref="WebDavServer" />;
/// or
/// <c>null</c> to use the built-in method handlers.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// <para>
/// <paramref name="listener" /> is <c>null</c>.
/// </para>
/// <para>- or -</para>
/// <para>
/// <paramref name="store" /> is <c>null</c>.
/// </para>
/// </exception>
/// <exception cref="System.ArgumentException">
/// <para>
/// <paramref name="methodHandlers" /> is empty.
/// </para>
/// <para>- or -</para>
/// <para>
/// <paramref name="methodHandlers" /> contains a <c>null</c>-reference.
/// </para>
/// </exception>
public WebDavServer(ref IWebDavStore store, IHttpListener listener = null, IEnumerable<IWebDavMethodHandler> methodHandlers = null)
{
ServicePointManager.DefaultConnectionLimit = DefaultConnectionLimit;
ServicePointManager.Expect100Continue = Expect100Continue;
ServicePointManager.MaxServicePoints = MaxServicePoints;
ServicePointManager.MaxServicePointIdleTime = int.MaxValue;
if (store == null)
throw new ArgumentNullException(nameof(store));
if (listener == null)
{
listener = new HttpListenerNegotiateAdapter();
_ownsListener = true;
}
methodHandlers = methodHandlers ?? WebDavMethodHandlers.BuiltIn;
IWebDavMethodHandler[] webDavMethodHandlers = methodHandlers as IWebDavMethodHandler[] ?? methodHandlers.ToArray();
if (!webDavMethodHandlers.Any())
throw new ArgumentException("The methodHandlers collection is empty", nameof(methodHandlers));
if (webDavMethodHandlers.Any(methodHandler => methodHandler == null))
throw new ArgumentException("The methodHandlers collection contains a null-reference", nameof(methodHandlers));
_listener = listener;
_store = store;
//_store.FClearCaches = DoClearCaches;
var handlersWithNames =
from methodHandler in webDavMethodHandlers
from name in methodHandler.Names
select new
{
name,
methodHandler
};
_methodHandlers = handlersWithNames.ToDictionary(v => v.name, v => v.methodHandler);
}
/// <summary>
/// Add a HTTP listener.
/// </summary>
/// <param name="listener"></param>
/// <exception cref="InvalidOperationException">Listener have been started.</exception>
public void Add(IHttpListener listener)
{
if (listener.IsStarted)
throw new InvalidOperationException("Listener have been started.");
_listeners.Add(listener);
}
public void Use(IHttpListener listener)
{
_listeners.Add(listener);
}
