public Task <IHttpResponse> Instigate(IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { return(EastFive.Web.Configuration.Settings.GetString(AppSettings.ApiKey, (authorizedApiKey) => { var queryParams = request.GetAbsoluteUri().ParseQueryString(); if (queryParams["ApiKeySecurity"] == authorizedApiKey) { return onSuccess(new Controllers.ApiSecurity { key = queryParams["ApiKeySecurity"], }); } var authorization = request.GetAuthorization(); if (authorization == authorizedApiKey) { return onSuccess(new Controllers.ApiSecurity { key = authorization, }); } return request.CreateResponse(HttpStatusCode.Unauthorized).AsTask(); }, (why) => request.CreateResponse(HttpStatusCode.Unauthorized).AddReason(why).AsTask())); }
public Task <IHttpResponse> HandleRouteAsync(Type controllerType, IInvokeResource resourceInvoker, IApplication httpApp, IHttpRequest request, RouteHandlingDelegate continueExecution) { if (!request.Headers.ContainsKey(HeaderKey)) { return(continueExecution(controllerType, httpApp, request)); } return(EastFive.Azure.AppSettings.TableInformationToken.ConfigurationString( async headerToken => { if (request.Headers[HeaderKey].First() != headerToken) { return request.CreateResponse(System.Net.HttpStatusCode.Unauthorized); } if (request.Headers.ContainsKey("X-StorageTableInformation-List")) { var tableData = await controllerType.StorageGetAll().ToArrayAsync(); return request.CreateExtrudedResponse( System.Net.HttpStatusCode.OK, tableData); } if (request.Headers.ContainsKey("X-StorageTableInformation-RepairModifiers")) { var query = request.Headers .Where(hdr => "X-StorageTableInformation-Query".Equals(hdr.Key, StringComparison.OrdinalIgnoreCase)) .First( (hdr, next) => hdr.Value.First( (hdrValue, next) => hdrValue, () => string.Empty), () => string.Empty); return new WriteStreamAsyncHttpResponse(request, System.Net.HttpStatusCode.OK, $"{controllerType.FullName}.repair.txt", "text/text", true, async stream => { string [] repairs = await controllerType .StorageRepairModifiers(query) .Select( async line => { var bytes = line.GetBytes(Encoding.UTF8); await stream.WriteAsync(bytes, 0, bytes.Length); return line; }) .Await(readAhead: 100) .ToArrayAsync(); }); } var tableInformation = await controllerType.StorageTableInformationAsync(); return request.CreateResponse(System.Net.HttpStatusCode.OK, tableInformation); }, why => continueExecution(controllerType, httpApp, request))); }
public static Task <IHttpResponse> GetClaimsAsync(this IHttpRequest request, Func <System.Security.Claims.Claim[], Task <IHttpResponse> > success) { var result = request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); return(success(claims)); }, () => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized).AddReason("Authorization header not set").AsTask(), (why) => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized).AddReason(why).AsTask()); return(result); }
public IHttpResponse CreateResponseAsync(IApplication httpApp, IHttpRequest request, Dictionary <string, object> queryParameterOptions, MethodInfo method, object[] methodParameters) { var response = request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, this.StackTrace); return(response.AddReason(this.Message)); }
public RequestControllerTest() { _controller = new MyController(); _request = new HttpTestRequest {HttpVersion = "HTTP/1.1"}; _stream = new MyStream(); _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); }
public ControllerModuleTest() { _controller = new TestController(); _request = new HttpTestRequest {HttpVersion = "HTTP/1.1"}; _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new ControllerModule(); }
public static IHttpResponse CreateResponseConfiguration(this IHttpRequest request, string configParameterName, string why) { var response = request .CreateResponse(HttpStatusCode.ServiceUnavailable) .AddReason(why); return(response); }
//public static HttpResponseMessage CreateRedirectResponse<TController>(this IHttpRequest request, UrlHelper url, // string routeName = null) //{ // var location = url.GetLocation<TController>(routeName); // return request.CreateRedirectResponse(location); //} public static IHttpResponse CreateRedirectResponse(this IHttpRequest request, Uri location, string routeName = null) { var response = request.CreateResponse(HttpStatusCode.Redirect); response.SetLocation(location); return(response); }
public FileModuleTest() { _request = new HttpTestRequest {HttpVersion = "HTTP/1.1"}; _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new FileModule("/files/", Environment.CurrentDirectory); _module.MimeTypes.Add("txt", "text/plain"); }
public static IHttpResponse CreateResponseUnexpectedFailure(this IHttpRequest request, string why) { var response = request .CreateResponse(HttpStatusCode.InternalServerError) .AddReason(why); return(response); }
//public static HttpResponseMessage CreateResponseSeeOther<TController>(this HttpRequestMessage request, Guid otherResourceId, UrlHelper url, // string routeName = null) //{ // var location = url.GetLocation<TController>(otherResourceId, routeName); // var response = request // .CreateResponse(HttpStatusCode.SeeOther); // response.Headers.Location = location; // return response; //} //public static HttpResponseMessage CreateAlreadyExistsResponse<TController>(this HttpRequestMessage request, Guid existingResourceId, UrlHelper url, // string routeName = null) //{ // var location = url.GetLocation<TController>(existingResourceId, routeName); // var reason = $"There is already a resource with ID = [{existingResourceId}]"; // var response = request // .CreateResponse(HttpStatusCode.Conflict) // .AddReason(reason); // response.Headers.Location = location; // return response; //} //public static HttpResponseMessage CreateAlreadyExistsResponse(this HttpRequestMessage request, Type controllerType, Guid existingResourceId, UrlHelper url, // string routeName = null) //{ // var location = url.GetLocation(controllerType, existingResourceId, routeName); // var reason = $"There is already a resource with ID = [{existingResourceId}]"; // var response = request // .CreateResponse(HttpStatusCode.Conflict) // .AddReason(reason); // response.Headers.Location = location; // return response; //} public static IHttpResponse CreateResponseNotFound(this IHttpRequest request, Guid resourceId) { var reason = $"The resource with ID = [{resourceId}] was not found"; var response = request .CreateResponse(HttpStatusCode.NotFound) .AddReason(reason); return(response); }
public static Task <IHttpResponse> Get(EastFive.Api.Security security, IHttpRequest request) { return(EastFive.Web.Configuration.Settings.GetGuid( EastFive.Api.AppSettings.ActorIdSuperAdmin, (actorIdSuperAdmin) => { if (actorIdSuperAdmin == security.performingAsActorId) { var settings = ConfigurationManager.AppSettings.AllKeys .Select(x => new AppSetting { Name = x, Value = ConfigurationManager.AppSettings[x] }).OrderBy(x => x.Name).ToArray(); return new JsonHttpResponse(request, System.Net.HttpStatusCode.OK, settings).AsTask <IHttpResponse>(); } return request.CreateResponse(System.Net.HttpStatusCode.NotFound).AsTask(); }, (why) => request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, why).AsTask())); }
protected void HandleHTTPRequest(IHttpClientContext context, IHttpRequest request) { Uri uri = request.Uri; string hostName = uri.Host; string pathAndQuery = uri.PathAndQuery; try { // Handle different HTTP methods here if (request.Method == "NOTIFY") { foreach (DeviceConnection connection in _connectedDevices.Values) { if (!NetworkHelper.HostNamesEqual(hostName, NetworkHelper.IPAddrToHostName(connection.GENAClientController.EventNotificationEndpoint.Address))) { continue; } if (pathAndQuery == connection.GENAClientController.EventNotificationPath) { IHttpResponse response = request.CreateResponse(context); response.Status = connection.GENAClientController.HandleUnicastEventNotification(request); response.Send(); return; } } } else { context.Respond(HttpHelper.HTTP11, HttpStatusCode.MethodNotAllowed, null); return; } // Url didn't match context.Respond(HttpHelper.HTTP11, HttpStatusCode.NotFound, null); return; } catch (Exception) // Don't log the exception here - we don't care about not being able to send the return value to the client { IHttpResponse response = request.CreateResponse(context); response.Status = HttpStatusCode.InternalServerError; response.Send(); return; } }
public ControllerModuleTest() { _controller = new TestController(); _request = new HttpTestRequest { HttpVersion = "HTTP/1.1" }; _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new ControllerModule(); }
public RequestControllerTest() { _controller = new MyController(); _request = new HttpTestRequest { HttpVersion = "HTTP/1.1" }; _stream = new MyStream(); _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); }
public ReverseProxyTest() { _request = new HttpTestRequest {HttpVersion = "HTTP/1.1"}; _stream = new MyStream(); _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new ReverseProxyModule("http://localhost/", "http://localhost:4210/"); _server = new HttpServer(); }
public FileModuleTest() { _request = new HttpTestRequest { HttpVersion = "HTTP/1.1" }; _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new FileModule("/files/", Environment.CurrentDirectory); _module.MimeTypes.Add("txt", "text/plain"); }
private void OnRequest(object source, RequestEventArgs args) { IHttpClientContext context = (IHttpClientContext)source; IHttpRequest request = args.Request; IHttpResponse response = request.CreateResponse(context); response.Body = new FileStream("Path\\to\\file.jpg"); response.ContentType = "image\jpeg"; response.Send(); }
public static IHttpResponse CreateResponseEmptyId <TQuery, TProperty>(this IHttpRequest request, TQuery query, Expression <Func <TQuery, TProperty> > propertyFailing) { var value = string.Empty; var reason = $"Property [{propertyFailing}] must have value."; var response = request .CreateResponse(HttpStatusCode.BadRequest) .AddReason(reason); return(response); }
public ReverseProxyTest() { _request = new HttpTestRequest { HttpVersion = "HTTP/1.1" }; _stream = new MyStream(); _context = new HttpResponseContext(); _response = _request.CreateResponse(_context); _module = new ReverseProxyModule("http://localhost/", "http://localhost:4210/"); _server = new HttpServer(); }
public static Task <IHttpResponse[]> GetActorIdClaimsAsync(this IHttpRequest request, string accountIdClaimType, Func <Guid, System.Security.Claims.Claim[], Task <IHttpResponse[]> > success) { var resultGetClaims = request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); var result = claims.GetAccountIdAsync( request, accountIdClaimType, (accountId) => success(accountId, claims)); return(result); }, () => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason("Authorization header not set").AsEnumerable().ToArray().AsTask(), (why) => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason(why).AsEnumerable().ToArray().AsTask()); return(resultGetClaims); }
public static IHttpResponse GetActorIdClaims(this IHttpRequest request, string accountIdClaimTypeConfigurationSetting, Func <Guid, System.Security.Claims.Claim[], IHttpResponse> success) { var resultGetClaims = request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); var accountIdClaimType = ConfigurationManager.AppSettings[accountIdClaimTypeConfigurationSetting]; var result = claims.GetAccountId( request, accountIdClaimType, (accountId) => success(accountId, claims)); return(result); }, () => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason("Authorization header not set"), (why) => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason(why)); return(resultGetClaims); }
public static Task <IHttpResponse> GetSessionIdClaimsAsync(this IHttpRequest request, string sessionIdClaimTypeConfigurationSetting, Func <Guid, System.Security.Claims.Claim[], Task <IHttpResponse> > success) { var resultGetClaims = request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); //var accountIdClaimType = // ConfigurationManager.AppSettings[sessionIdClaimTypeConfigurationSetting]; var sessionIdClaimType = Auth.ClaimEnableSessionAttribute.Type; var result = claims.GetSessionIdAsync( request, sessionIdClaimType, (sessionId) => success(sessionId, claims)); return(result); }, () => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason("Authorization header not set").AsTask(), (why) => request.CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason(why).AsTask()); return(resultGetClaims); }
private void OnSecureRequest(object source, RequestEventArgs args) { IHttpClientContext context = (IHttpClientContext)source; IHttpRequest request = args.Request; // Here we create a response object, instead of using the client directly. // we can use methods like Redirect etc with it, // and we dont need to keep track of any headers etc. IHttpResponse response = request.CreateResponse(context); byte[] body = Encoding.UTF8.GetBytes("Hello secure you!"); response.Body.Write(body, 0, body.Length); response.Send(); }
public override Task <IHttpResponse> InstigateInternal(IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { Func <IHttpResponse> responseFunc = () => { var response = request.CreateResponse(this.StatusCode); return(UpdateResponse(parameterInfo, httpApp, request, response)); }; var responseDelegate = responseFunc.MakeDelegate(parameterInfo.ParameterType); return(onSuccess(responseDelegate)); }
void _listener_RequestReceived(object sender, RequestEventArgs e) { if (ProcessRequest != null) { IHttpClientContext context = (IHttpClientContext)sender; IHttpRequest request = e.Request; IHttpResponse response = request.CreateResponse(context); StreamWriter writer = new StreamWriter(response.Body); ProcessRequest(request, writer); writer.Flush(); response.Send(); writer.Close(); } }
public static Task <IHttpResponse> GetSessionIdAsync(this IEnumerable <System.Security.Claims.Claim> claims, IHttpRequest request, string sessionIdClaimType, Func <Guid, Task <IHttpResponse> > success) { return(claims .Where(claim => String.Compare(claim.Type, sessionIdClaimType) == 0) .First( (adminClaim, next) => { var accountId = Guid.Parse(adminClaim.Value); return success(accountId); }, () => request.CreateResponse(HttpStatusCode.Unauthorized).AsTask())); }
private static IHttpResponse CreateHttpMultipartResponse(this IHttpRequest request, IEnumerable <IHttpRequest> contents) { var multipartContent = new MultipartContent("mixed", "----Boundary_" + Guid.NewGuid().ToString("N")); request.CreateResponse(HttpStatusCode.OK, multipartContent); throw new NotImplementedException(); //foreach (var content in contents) //{ // multipartContent.Add(new HttpMessageContent(content)); //} //var response = request.CreateResponse(HttpStatusCode.OK); //response.Content = multipartContent; //return response; }
public Task <IHttpResponse> Instigate(IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { return(request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); return claims.GetAccountIdMaybe( request, Auth.ClaimEnableActorAttribute.Type, (accountIdMaybe) => { var sessionIdClaimType = Auth.ClaimEnableSessionAttribute.Type; return claims.GetSessionIdAsync( request, sessionIdClaimType, (sessionId) => { var token = new SessionToken { accountIdMaybe = accountIdMaybe, sessionId = sessionId, claims = claims, }; return onSuccess(token); }); }); }, () => request .CreateResponse(HttpStatusCode.Unauthorized) .AddReason("Authorization header not set.") .AsTask(), (why) => request .CreateResponse(HttpStatusCode.Unauthorized) .AddReason(why) .AsTask())); }
public static Task <IHttpResponse> GetActorIdClaimsAsync(this IHttpRequest request, Func <Guid, System.Security.Claims.Claim[], Task <IHttpResponse> > success) { var resultGetClaims = request.GetClaims( (claimsEnumerable) => { var claims = claimsEnumerable.ToArray(); var accountIdClaimType = EastFive.Api.AppSettings.ActorIdClaimType.ConfigurationString( configValue => configValue, onUnspecified: (why) => "http://schemas.xmlsoap.org/ws/2009/09/identity/claims/actor"); var result = claims.GetAccountIdAsync( request, accountIdClaimType, (accountId) => success(accountId, claims)); return(result); }, () => request .CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason("Authorization header not set").AsTask(), (why) => request .CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason(why).AsTask()); return(resultGetClaims); }
public override Task <IHttpResponse> InstigateInternal(IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { AlreadyExistsReferencedResponse dele = (existingId) => { var response = request .CreateResponse(StatusCode) .AddReason($"There is already a resource with ID = [{existingId}]"); return(UpdateResponse(parameterInfo, httpApp, request, response)); }; return(onSuccess((object)dele)); }
public Task <IHttpResponse> ValidateRequest( KeyValuePair <ParameterInfo, object>[] parameterSelection, MethodInfo method, IApplication httpApp, IHttpRequest request, ValidateHttpDelegate boundCallback) { Func <string, bool> roleInterigator = request.Properties.TryGetValueNullSafe(Token.PropertyName, out object tokenObj) ? (roll) => ((Token)tokenObj).IsAuthorizedForRoll(roll) : (roll) => request.IsAuthorizedForRole(roll); return(ProcessClaimsAsync(roleInterigator)); Task <IHttpResponse> ProcessClaimsAsync(Func <string, bool> doesContainRole) { return(RolesDenied .NullToEmpty() .Where(rollAllowed => doesContainRole(rollAllowed)) .First( (rollDenied, next) => { return DenyAsync("denies", rollDenied); }, () => { if (!RolesAllowed.Any()) { return boundCallback(parameterSelection, method, httpApp, request); } return RolesAllowed .Where(rollAllowed => doesContainRole(rollAllowed)) .First( (rollAllowed, next) => boundCallback(parameterSelection, method, httpApp, request), () => DenyAsync("requires one of", RolesAllowed.Join(','))); })); } Task <IHttpResponse> DenyAsync(string action, string equals) { return(request .CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason($"{method.DeclaringType.FullName}..{method.Name} {action} role claim ({ClaimTypes.Role}) = `{equals}`") .AsTask()); } }
public Task <IHttpResponse> ValidateRequest( KeyValuePair <ParameterInfo, object>[] parameterSelection, MethodInfo method, IApplication httpApp, IHttpRequest request, ValidateHttpDelegate boundCallback) { if (!request.IsAuthorizedForRole(ClaimValue)) { return(request .CreateResponse(System.Net.HttpStatusCode.Unauthorized) .AddReason($"{method.DeclaringType.FullName}..{method.Name} requires roll claim `{ClaimValue}`") .AsTask()); } return(boundCallback(parameterSelection, method, httpApp, request)); }
public override Task <IHttpResponse> InstigateInternal(IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { ConfigurationFailureResponse responseDelegate = (configurationValue, message) => { var response = request .CreateResponse(System.Net.HttpStatusCode.ServiceUnavailable) .AddReason($"`{configurationValue}` not specified in config:{message}"); return(UpdateResponse(parameterInfo, httpApp, request, response)); }; return(onSuccess(responseDelegate)); }
/// <summary> /// Handles SUBSCRIBE and UNSUBSCRIBE HTTP requests. /// </summary> /// <param name="request">The HTTP request instance to handle</param> /// <param name="context">The HTTP client context of the specified <paramref name="request"/>.</param> /// <param name="config">The UPnP endpoint over that the HTTP request was received.</param> /// <returns><c>true</c> if the request could be handled and a HTTP response was sent, else <c>false</c>.</returns> public bool HandleHTTPRequest(IHttpRequest request, IHttpClientContext context, EndpointConfiguration config) { if (request.Method == "SUBSCRIBE") { // SUBSCRIBE events string pathAndQuery = request.Uri.PathAndQuery; DvService service; if (config.EventSubPathsToServices.TryGetValue(pathAndQuery, out service)) { IHttpResponse response = request.CreateResponse(context); string httpVersion = request.HttpVersion; string userAgentStr = request.Headers.Get("USER-AGENT"); string callbackURLsStr = request.Headers.Get("CALLBACK"); string nt = request.Headers.Get("NT"); string sid = request.Headers.Get("SID"); string timeoutStr = request.Headers.Get("TIMEOUT"); int timeout = UPnPConsts.GENA_DEFAULT_SUBSCRIPTION_TIMEOUT; ICollection<string> callbackURLs = null; if ((!string.IsNullOrEmpty(timeoutStr) && (!timeoutStr.StartsWith("Second-") || !int.TryParse(timeoutStr.Substring("Second-".Length).Trim(), out timeout))) || (!string.IsNullOrEmpty(callbackURLsStr) && !TryParseCallbackURLs(callbackURLsStr, out callbackURLs))) { response.Status = HttpStatusCode.BadRequest; response.Send(); return true; } if (!string.IsNullOrEmpty(sid) && (callbackURLs != null || !string.IsNullOrEmpty(nt))) { response.Status = HttpStatusCode.BadRequest; response.Reason = "Incompatible Header Fields"; response.Send(); return true; } if (callbackURLs != null && !string.IsNullOrEmpty(nt)) { // Subscription bool subscriberSupportsUPnP11; try { if (string.IsNullOrEmpty(userAgentStr)) subscriberSupportsUPnP11 = false; else { int minorVersion; if (!ParserHelper.ParseUserAgentUPnP1MinorVersion(userAgentStr, out minorVersion)) { response.Status = HttpStatusCode.BadRequest; response.Send(); return true; } subscriberSupportsUPnP11 = minorVersion >= 1; } } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("GENAServerController: Error in event subscription", e); response.Status = HttpStatusCode.BadRequest; response.Send(); return true; } if (service.HasComplexStateVariables && !subscriberSupportsUPnP11) { response.Status = HttpStatusCode.ServiceUnavailable; response.Send(); return true; } bool validURLs = callbackURLs.All(url => url.StartsWith("http://")); if (nt != "upnp:event" || !validURLs) { response.Status = HttpStatusCode.PreconditionFailed; response.Reason = "Precondition Failed"; response.Send(); return true; } DateTime date; if (Subscribe(config, service, callbackURLs, httpVersion, subscriberSupportsUPnP11, ref timeout, out date, out sid)) { response.Status = HttpStatusCode.OK; response.AddHeader("DATE", date.ToUniversalTime().ToString("R")); response.AddHeader("SERVER", UPnPConfiguration.UPnPMachineInfoHeader); response.AddHeader("SID", sid); response.AddHeader("CONTENT-LENGTH", "0"); response.AddHeader("TIMEOUT", "Second-"+timeout); response.Send(); SendInitialEventNotification(sid); return true; } response.Status = HttpStatusCode.ServiceUnavailable; response.Reason = "Unable to accept renewal"; // See (DevArch), table 4-4 response.Send(); return true; } if (!string.IsNullOrEmpty(sid)) { // Renewal DateTime date; if (RenewSubscription(config, sid, ref timeout, out date)) { response.Status = HttpStatusCode.OK; response.AddHeader("DATE", date.ToUniversalTime().ToString("R")); response.AddHeader("SERVER", UPnPConfiguration.UPnPMachineInfoHeader); response.AddHeader("SID", sid); response.AddHeader("CONTENT-LENGTH", "0"); response.AddHeader("TIMEOUT", "Second-"+timeout); response.Send(); return true; } response.Status = HttpStatusCode.ServiceUnavailable; response.Reason = "Unable to accept renewal"; response.Send(); return true; } } } else if (request.Method == "UNSUBSCRIBE") { // UNSUBSCRIBE events string pathAndQuery = request.Uri.PathAndQuery; DvService service; if (config.EventSubPathsToServices.TryGetValue(pathAndQuery, out service)) { IHttpResponse response = request.CreateResponse(context); string sid = request.Headers.Get("SID"); string callbackURL = request.Headers.Get("CALLBACK"); string nt = request.Headers.Get("NT"); if (string.IsNullOrEmpty(sid) || !string.IsNullOrEmpty(callbackURL) || !string.IsNullOrEmpty(nt)) { response.Status = HttpStatusCode.BadRequest; response.Reason = "Incompatible Header Fields"; response.Send(); return true; } if (Unsubscribe(config, sid)) { response.Status = HttpStatusCode.OK; response.Send(); return true; } response.Status = HttpStatusCode.PreconditionFailed; response.Reason = "Precondition Failed"; response.Send(); return true; } } return false; }
private void ProcessRequest(IHttpClientContext context, IHttpRequest request) { IHttpResponse response = request.CreateResponse(context); try { foreach (IRule rule in _rules) { if (!rule.Process(request, response)) continue; response.Send(); return; } // load cookies if the exist. RequestCookies cookies = request.Headers["cookie"] != null ? new RequestCookies(request.Headers["cookie"]) : new RequestCookies(string.Empty); request.SetCookies(cookies); IHttpSession session; if (cookies[_sessionCookieName] != null) { string sessionCookie = cookies[_sessionCookieName].Value; // there's a bug somewhere which messes up headers which can render the session cookie useless. // therefore let's consider the session cookie as not set if that have happened. if (sessionCookie.Length > 40) { _logWriter.Write(this, LogPrio.Error, "Session cookie is invalid: " + sessionCookie); cookies.Remove(_sessionCookieName); _sessionStore.Remove(sessionCookie); // free the session cookie (and thus generating a new one). session = _sessionStore.Create(); } else session = _sessionStore.Load(sessionCookie) ?? _sessionStore.Create(sessionCookie); } else session = _sessionStore.Create(); HandleRequest(context, request, response, session); } catch (Exception err) { if (_exceptionHandler == null) #if DEBUG throw; #else { WriteLog(LogPrio.Fatal, err.Message); return; } #endif _exceptionHandler(this, err); Exception e = err; while (e != null) { if (e is SocketException) return; e = e.InnerException; } try { #if DEBUG context.Respond("HTTP/1.0", HttpStatusCode.InternalServerError, "Internal server error", err.ToString(), "text/plain"); #else context.Respond("HTTP/1.0", HttpStatusCode.InternalServerError, "Internal server error"); #endif } catch (Exception err2) { LogWriter.Write(this, LogPrio.Fatal, "Failed to respond on message with Internal Server Error: " + err2); } } }
private bool AuthenticateUser(ITcpChannel channel, IHttpRequest request) { if (channel.Data["Principal"] != null) { Thread.CurrentPrincipal = (IPrincipal)channel.Data["Principal"]; return true; } try { var user = AuthenticationService.Authenticate(request); if (user == null) return true; if (PrincipalFactory != null) { var ctx = new PrincipalFactoryContext(request, user); Thread.CurrentPrincipal = PrincipalFactory.Create(ctx); channel.Data["Principal"] = Thread.CurrentPrincipal; return true; } var roles = user as IUserWithRoles; if (roles == null) throw new InvalidOperationException( "You must specify a PrincipalFactory if you do not return a IUserWithRoles from your IAccountService."); Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(user.Username), roles.RoleNames); channel.Data["Principal"] = Thread.CurrentPrincipal; } catch (HttpException ex) { var response = request.CreateResponse(); response.StatusCode = ex.HttpCode; response.ReasonPhrase = FirstLine(ex.Message); ; channel.Send(response); return false; } return true; }
/// <summary> /// Handles all kinds of HTTP over TCP requests - Description, Control and Event subscriptions. /// </summary> /// <param name="context">HTTP client context of the current request.</param> /// <param name="request">HTTP request to handle.</param> protected void HandleHTTPRequest_NoLock(IHttpClientContext context, IHttpRequest request) { Uri uri = request.Uri; string hostName = uri.Host; string pathAndQuery = uri.LocalPath; // Unfortunately, Uri.PathAndQuery doesn't decode characters like '{' and '}', so we use the Uri.LocalPath property try { DvService service; ICollection<EndpointConfiguration> endpoints; lock (_serverData.SyncObj) endpoints = _serverData.UPnPEndPoints; foreach (EndpointConfiguration config in endpoints) { if (!NetworkHelper.HostNamesEqual(hostName, NetworkHelper.IPAddrToHostName(config.EndPointIPAddress))) continue; // Common check for supported encodings string acceptEncoding = request.Headers.Get("ACCEPT-ENCODING") ?? string.Empty; // Handle different HTTP methods here if (request.Method == "GET") { // GET of descriptions if (pathAndQuery.StartsWith(config.DescriptionPathBase)) { string acceptLanguage = request.Headers.Get("ACCEPT-LANGUAGE"); CultureInfo culture = GetFirstCultureOrDefault(acceptLanguage, CultureInfo.InvariantCulture); string description = null; DvDevice rootDevice; lock (_serverData.SyncObj) if (config.RootDeviceDescriptionPathsToRootDevices.TryGetValue(pathAndQuery, out rootDevice)) description = rootDevice.BuildRootDeviceDescription(_serverData, config, culture); else if (config.SCPDPathsToServices.TryGetValue(pathAndQuery, out service)) description = service.BuildSCPDDocument(config, _serverData); if (description != null) { IHttpResponse response = request.CreateResponse(context); response.Status = HttpStatusCode.OK; response.ContentType = "text/xml; charset=utf-8"; if (!string.IsNullOrEmpty(acceptLanguage)) response.AddHeader("CONTENT-LANGUAGE", culture.ToString()); using (MemoryStream responseStream = new MemoryStream(UPnPConsts.UTF8_NO_BOM.GetBytes(description))) CompressionHelper.WriteCompressedStream(acceptEncoding, response, responseStream); SafeSendResponse(response); return; } } } else if (request.Method == "POST") { // POST of control messages if (config.ControlPathsToServices.TryGetValue(pathAndQuery, out service)) { string contentType = request.Headers.Get("CONTENT-TYPE"); string userAgentStr = request.Headers.Get("USER-AGENT"); IHttpResponse response = request.CreateResponse(context); int minorVersion; if (string.IsNullOrEmpty(userAgentStr)) minorVersion = 0; else if (!ParserHelper.ParseUserAgentUPnP1MinorVersion(userAgentStr, out minorVersion)) { response.Status = HttpStatusCode.BadRequest; SafeSendResponse(response); return; } string mediaType; Encoding encoding; if (!EncodingUtils.TryParseContentTypeEncoding(contentType, Encoding.UTF8, out mediaType, out encoding)) throw new ArgumentException("Unable to parse content type"); if (mediaType != "text/xml") { // As specified in (DevArch), 3.2.1 response.Status = HttpStatusCode.UnsupportedMediaType; SafeSendResponse(response); return; } response.AddHeader("DATE", DateTime.Now.ToUniversalTime().ToString("R")); response.AddHeader("SERVER", UPnPConfiguration.UPnPMachineInfoHeader); response.AddHeader("CONTENT-TYPE", "text/xml; charset=\"utf-8\""); string result; HttpStatusCode status; try { CallContext callContext = new CallContext(request, context, config); status = SOAPHandler.HandleRequest(service, request.Body, encoding, minorVersion >= 1, callContext, out result); } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("Action invocation failed", e); result = SOAPHandler.CreateFaultDocument(501, "Action failed"); status = HttpStatusCode.InternalServerError; } response.Status = status; using (MemoryStream responseStream = new MemoryStream(encoding.GetBytes(result))) CompressionHelper.WriteCompressedStream(acceptEncoding, response, responseStream); SafeSendResponse(response); return; } } else if (request.Method == "SUBSCRIBE" || request.Method == "UNSUBSCRIBE") { GENAServerController gsc; lock (_serverData.SyncObj) gsc = _serverData.GENAController; if (gsc.HandleHTTPRequest(request, context, config)) return; } else { context.Respond(HttpHelper.HTTP11, HttpStatusCode.MethodNotAllowed, null); return; } } // Url didn't match context.Respond(HttpHelper.HTTP11, HttpStatusCode.NotFound, null); } catch (Exception e) { UPnPConfiguration.LOGGER.Error("UPnPServer: Error handling HTTP request '{0}'", e, uri); IHttpResponse response = request.CreateResponse(context); response.Status = HttpStatusCode.InternalServerError; SafeSendResponse(response); } }
void ProcessRequest(IHttpClientContext context, IHttpRequest request) { LogWriter.Write(this, LogPrio.Trace, "Processing request..."); IHttpResponse response = request.CreateResponse(context); // Load cookies if they exist RequestCookies cookies = request.Headers["cookie"] != null ? new RequestCookies(request.Headers["cookie"]) : new RequestCookies(String.Empty); request.SetCookies(cookies); // Create a request signature HttpRequestSignature signature = new HttpRequestSignature(request); // Look for a signature match in our handlers HttpRequestHandler foundHandler = null; bool doLock = !rwHandlersLock.IsReadLockHeld; if (doLock) rwHandlersLock.EnterReadLock(); try { for (int i = 0; i < _requestHandlers.Length; i++) { HttpRequestHandler handler = _requestHandlers[i]; if (signature == handler.Signature) { foundHandler = handler; break; } } } finally { if (doLock) rwHandlersLock.ExitReadLock(); } if (foundHandler != null) FireRequestCallback(context, request, response, foundHandler); else FireRequestCallback(context, request, response, _notFoundHandler); LogWriter.Write(this, LogPrio.Trace, "...done processing request."); }
protected void HandleHTTPRequest(IHttpClientContext context, IHttpRequest request) { Uri uri = request.Uri; string hostName = uri.Host; string pathAndQuery = uri.PathAndQuery; try { // Handle different HTTP methods here if (request.Method == "NOTIFY") { foreach (DeviceConnection connection in _connectedDevices.Values) { if (!NetworkHelper.HostNamesEqual(hostName, NetworkHelper.IPAddrToHostName(connection.GENAClientController.EventNotificationEndpoint.Address))) continue; if (pathAndQuery == connection.GENAClientController.EventNotificationPath) { IHttpResponse response = request.CreateResponse(context); response.Status = connection.GENAClientController.HandleUnicastEventNotification(request); response.Send(); return; } } } else { context.Respond(HttpHelper.HTTP11, HttpStatusCode.MethodNotAllowed, null); return; } // Url didn't match context.Respond(HttpHelper.HTTP11, HttpStatusCode.NotFound, null); } catch (Exception) // Don't log the exception here - we don't care about not being able to send the return value to the client { IHttpResponse response = request.CreateResponse(context); response.Status = HttpStatusCode.InternalServerError; response.Send(); } }