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