private void AddHeaderToRequest(IHttpRequest request, string headerLine) { var headerParts = headerLine.Split(new[] { ':' }, 2); var headerName = headerParts[0].Trim(); var headerValue = headerParts.Length == 2 ? headerParts[1].Trim() : string.Empty; request.AddHeader(headerName, headerValue); }
public static IHttpHandler MatchesRequest(IHttpRequest request) { var file = GetFileNameWithoutExtension(request.PathInfo); return file != null && file.StartsWith("ssr-") ? new MiniProfilerHandler() : null; }
public new void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { if (!AssertAccess(httpReq, httpRes, httpReq.QueryString["op"])) return; var operationTypes = EndpointHost.Metadata.GetAllTypes(); if (httpReq.QueryString["xsd"] != null) { var xsdNo = Convert.ToInt32(httpReq.QueryString["xsd"]); var schemaSet = XsdUtils.GetXmlSchemaSet(operationTypes); var schemas = schemaSet.Schemas(); var i = 0; if (xsdNo >= schemas.Count) { throw new ArgumentOutOfRangeException("xsd"); } httpRes.ContentType = "text/xml"; foreach (XmlSchema schema in schemaSet.Schemas()) { if (xsdNo != i++) continue; schema.Write(httpRes.OutputStream); break; } return; } using (var sw = new StreamWriter(httpRes.OutputStream)) { var writer = new HtmlTextWriter(sw); httpRes.ContentType = "text/html"; ProcessOperations(writer, httpReq, httpRes); } }
public static void RequestFilter(IHttpRequest req, IHttpResponse res, object requestDto) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); if (validator == null) return; var validatorWithHttpRequest = validator as IRequiresHttpRequest; if (validatorWithHttpRequest != null) validatorWithHttpRequest.HttpRequest = req; var ruleSet = req.HttpMethod; var validationResult = validator.Validate( new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet))); if (validationResult.IsValid) return; var errorResponse = DtoUtils.CreateErrorResponse( requestDto, validationResult.ToErrorResult()); var validationFeature = EndpointHost.GetPlugin<ValidationFeature>(); if (validationFeature != null && validationFeature.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse); } res.WriteToResponse(req, errorResponse); }
public static object DeserializeHttpRequest(Type operationType, IHttpRequest httpReq, string contentType) { var httpMethod = httpReq.HttpMethod; var queryString = httpReq.QueryString; if (httpMethod == HttpMethods.Get || httpMethod == HttpMethods.Delete || httpMethod == HttpMethods.Options) { try { return KeyValueDataContractDeserializer.Instance.Parse(queryString, operationType); } catch (Exception ex) { var msg = "Could not deserialize '{0}' request using KeyValueDataContractDeserializer: '{1}'.\nError: '{2}'" .Fmt(operationType, queryString, ex); throw new SerializationException(msg); } } var isFormData = httpReq.HasAnyOfContentTypes(ContentType.FormUrlEncoded, ContentType.MultiPartFormData); if (isFormData) { try { return KeyValueDataContractDeserializer.Instance.Parse(httpReq.FormData, operationType); } catch (Exception ex) { throw new SerializationException("Error deserializing FormData: " + httpReq.FormData, ex); } } var request = CreateContentTypeRequest(httpReq, operationType, contentType); return request; }
/// <summary> /// Used in Unit tests /// </summary> /// <returns></returns> public override object CreateRequest(IHttpRequest httpReq, string operationName) { if (this.RestPath == null) throw new ArgumentNullException("No RestPath found"); return GetRequest(httpReq, this.RestPath); }
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request) { var requestContentType = ContentType.GetEndpointAttributes(httpReq.ResponseContentType); return ExecuteService(request, HandlerAttributes | requestContentType | GetEndpointAttributes(httpReq), httpReq, httpRes); }
public new void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { EndpointHost.Config.AssertFeatures(Feature.Metadata); var operations = EndpointHost.ServiceOperations; if (httpReq.QueryString["xsd"] != null) { var xsdNo = Convert.ToInt32(httpReq.QueryString["xsd"]); var schemaSet = XsdUtils.GetXmlSchemaSet(operations.AllOperations.Types); var schemas = schemaSet.Schemas(); var i = 0; if (xsdNo >= schemas.Count) { throw new ArgumentOutOfRangeException("xsd"); } httpRes.ContentType = "text/xml"; foreach (XmlSchema schema in schemaSet.Schemas()) { if (xsdNo != i++) continue; schema.Write(httpRes.Output); break; } return; } var writer = new HtmlTextWriter(httpRes.Output); httpRes.ContentType = "text/html"; ProcessOperations(writer, httpReq); writer.Flush(); }
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName) { response.ContentType = "text/plain"; response.StatusCode = 403; response.Write("Forbidden\n\n"); response.Write("\nRequest.HttpMethod: " + request.HttpMethod); response.Write("\nRequest.PathInfo: " + request.PathInfo); response.Write("\nRequest.QueryString: " + request.QueryString); response.Write("\nRequest.RawUrl: " + request.RawUrl); if (IsIntegratedPipeline.HasValue) response.Write("\nApp.IsIntegratedPipeline: " + IsIntegratedPipeline); if (!WebHostPhysicalPath.IsNullOrEmpty()) response.Write("\nApp.WebHostPhysicalPath: " + WebHostPhysicalPath); if (!WebHostRootFileNames.IsEmpty()) response.Write("\nApp.WebHostRootFileNames: " + TypeSerializer.SerializeToString(WebHostRootFileNames)); if (!ApplicationBaseUrl.IsNullOrEmpty()) response.Write("\nApp.ApplicationBaseUrl: " + ApplicationBaseUrl); if (!DefaultRootFileName.IsNullOrEmpty()) response.Write("\nApp.DefaultRootFileName: " + DefaultRootFileName); if (!DefaultHandler.IsNullOrEmpty()) response.Write("\nApp.DefaultHandler: " + DefaultHandler); if (!ServiceStackHttpHandlerFactory.DebugLastHandlerArgs.IsNullOrEmpty()) response.Write("\nApp.DebugLastHandlerArgs: " + ServiceStackHttpHandlerFactory.DebugLastHandlerArgs); ServiceStack.WebHost.Endpoints.EndpointHost.AddGlobalResponseHeaders(response); //Apache+mod_mono doesn't like this //response.OutputStream.Flush(); //response.Close(); }
//Also shared by RequiredRoleAttribute and RequiredPermissionAttribute public static User AuthenticateBasicAuth(IHttpRequest req, IHttpResponse res) { var userCredentialsPair = req.GetBasicAuthUserAndPassword(); var email = userCredentialsPair.HasValue ? userCredentialsPair.Value.Key : String.Empty; var password = userCredentialsPair.HasValue ? userCredentialsPair.Value.Value : String.Empty; User user = null; bool isValid = false; using (var session = NHibernateHelper.OpenSession()) { using (var transaction = session.BeginTransaction()) { var userQuery = session.QueryOver<User>() .Where(table => table.Email == email) .And(table => table.Password == password); user = userQuery.SingleOrDefault(); transaction.Commit(); isValid = (user != null); } } if (!isValid) { res.StatusCode = (int)HttpStatusCode.Unauthorized; res.EndServiceStackRequest(); } return user; }
private void SimplePreRequestFilter(IHttpRequest req, IHttpResponse res) { if (Path.GetFileName(req.PathInfo).StartsWith("_")) { throw new HttpException("Files with leading underscores ('_') cannot be served."); } }
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { var isDebugRequest = httpReq.RawUrl.ToLower().Contains("debug"); if (!isDebugRequest) { base.ProcessRequest(httpReq, httpRes, operationName); return; } try { var request = CreateRequest(httpReq, operationName); var response = ExecuteService(request, HandlerAttributes | GetEndpointAttributes(httpReq), httpReq); WriteDebugResponse(httpRes, response); } catch (Exception ex) { var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message); httpRes.WriteErrorToResponse(EndpointAttributes.Jsv, operationName, errorMessage, ex); } }
public static bool WriteToResponse(this IHttpResponse httpRes, IHttpRequest httpReq, object result, byte[] bodyPrefix, byte[] bodySuffix) { if (result == null) { httpRes.EndHttpRequestWithNoContent(); return true; } var serializationContext = new HttpRequestContext(httpReq, httpRes, result); var httpResult = result as IHttpResult; if (httpResult != null) { if (httpResult.ResponseFilter == null) { httpResult.ResponseFilter = EndpointHost.AppHost.ContentTypeFilters; } httpResult.RequestContext = serializationContext; serializationContext.ResponseContentType = httpResult.ContentType ?? httpReq.ResponseContentType; var httpResSerializer = httpResult.ResponseFilter.GetResponseSerializer(serializationContext.ResponseContentType); return httpRes.WriteToResponse(httpResult, httpResSerializer, serializationContext, bodyPrefix, bodySuffix); } var serializer = EndpointHost.AppHost.ContentTypeFilters.GetResponseSerializer(httpReq.ResponseContentType); return httpRes.WriteToResponse(result, serializer, serializationContext, bodyPrefix, bodySuffix); }
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request) { var response = ExecuteService(request, HandlerAttributes | httpReq.GetAttributes(), httpReq, httpRes); return response; }
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { try { EndpointHost.Config.AssertFeatures(format); if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes)) return; httpReq.ResponseContentType = httpReq.GetQueryStringContentType() ?? this.HandlerContentType; var callback = httpReq.QueryString["callback"]; var doJsonp = EndpointHost.Config.AllowJsonpRequests && !string.IsNullOrEmpty(callback); var request = CreateRequest(httpReq, operationName); if (EndpointHost.ApplyRequestFilters(httpReq, httpRes, request)) return; var response = GetResponse(httpReq, httpRes, request); if (EndpointHost.ApplyResponseFilters(httpReq, httpRes, response)) return; if (doJsonp && !(response is CompressedResult)) httpRes.WriteToResponse(httpReq, response, (callback + "(").ToUtf8Bytes(), ")".ToUtf8Bytes()); else httpRes.WriteToResponse(httpReq, response); } catch (Exception ex) { if (!EndpointHost.Config.WriteErrorsToResponse) throw; HandleException(httpReq, httpRes, operationName, ex); } }
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { httpRes.ContentType = ContentType.Html; if (RazorFormat == null) RazorFormat = RazorFormat.Instance; var contentPage = RazorPage ?? RazorFormat.FindByPathInfo(PathInfo); if (contentPage == null) { httpRes.StatusCode = (int)HttpStatusCode.NotFound; httpRes.EndHttpRequest(); return; } if (RazorFormat.WatchForModifiedPages) RazorFormat.ReloadIfNeeeded(contentPage); //Add good caching support //if (httpReq.DidReturn304NotModified(contentPage.GetLastModified(), httpRes)) // return; var model = Model; if (model == null) httpReq.Items.TryGetValue("Model", out model); if (model == null) { var modelType = RazorPage != null ? RazorPage.GetRazorTemplate().ModelType : null; model = modelType == null || modelType == typeof(DynamicRequestObject) ? null : DeserializeHttpRequest(modelType, httpReq, httpReq.ContentType); } RazorFormat.ProcessRazorPage(httpReq, contentPage, model, httpRes); }
protected override void RenderOperation(System.Web.UI.HtmlTextWriter writer, IHttpRequest httpReq, string operationName, string requestMessage, string responseMessage, string metadataHtml) { var operationControl = new Soap12OperationControl { HttpRequest = httpReq, MetadataConfig = EndpointHost.Config.ServiceEndpointsMetadataConfig, Title = EndpointHost.Config.ServiceName, Format = this.Format, OperationName = operationName, HostName = httpReq.GetUrlHostName(), RequestMessage = requestMessage, ResponseMessage = responseMessage, MetadataHtml = metadataHtml, }; if (!this.ContentType.IsNullOrEmpty()) { operationControl.ContentType = this.ContentType; } if (!this.ContentFormat.IsNullOrEmpty()) { operationControl.ContentFormat = this.ContentFormat; } operationControl.Render(writer); }
public byte[] EvaluateConnectionFilters( IHttpRequest args, string connectionId ) { if (!_settings.FilteringEnabled.Value || IsWhitelisted(args, connectionId)) { return null; } if ( ConnectionFilters !=null && ConnectionFilters.Count() > 0 ) { string errorMessage = ConnectionFilters.OrderBy( s => s.FilterSpeedType ) .Select( filter => filter.EvaluateFilter( args, connectionId ) ) .FirstOrDefault( filterText => !String.IsNullOrEmpty( filterText ) ); if ( !String.IsNullOrEmpty( errorMessage ) ) { string body = String.Format( "<html><head><title>Gallatin Proxy - Connection Rejected</title></head><body>{0}</body></html>", errorMessage ); return Encoding.UTF8.GetBytes( String.Format( "HTTP/{0} 200 OK\r\nConnection: close\r\nContent length: {1}\r\nContent-Type: text/html\r\n\r\n{2}", args.Version, body.Length, body ) ); } } return null; }
/// <summary> /// Non ASP.NET requests /// </summary> /// <param name="request"></param> /// <param name="response"></param> /// <param name="operationName"></param> public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName) { if (string.IsNullOrEmpty(RelativeUrl) && string.IsNullOrEmpty(AbsoluteUrl)) throw new ArgumentNullException("RelativeUrl or AbsoluteUrl"); if (!string.IsNullOrEmpty(AbsoluteUrl)) { response.StatusCode = (int)HttpStatusCode.Redirect; response.AddHeader(HttpHeaders.Location, this.AbsoluteUrl); } else { var absoluteUrl = request.GetApplicationUrl(); if (!string.IsNullOrEmpty(RelativeUrl)) { if (this.RelativeUrl.StartsWith("/")) absoluteUrl = absoluteUrl.CombineWith(this.RelativeUrl); else if (this.RelativeUrl.StartsWith("~/")) absoluteUrl = absoluteUrl.CombineWith(this.RelativeUrl.Replace("~/", "")); else absoluteUrl = request.AbsoluteUri.CombineWith(this.RelativeUrl); } response.StatusCode = (int)HttpStatusCode.Redirect; response.AddHeader(HttpHeaders.Location, absoluteUrl); } response.EndHttpRequest(skipClose:true); }
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { httpRes.ContentType = MimeTypes.Html; if (RazorFormat == null) RazorFormat = RazorFormat.Instance; var contentPage = RazorPage ?? RazorFormat.FindByPathInfo(PathInfo); if (contentPage == null) { httpRes.StatusCode = (int)HttpStatusCode.NotFound; httpRes.EndHttpHandlerRequest(); return; } var model = Model; if (model == null) httpReq.Items.TryGetValue("Model", out model); if (model == null) { var modelType = RazorPage != null ? RazorPage.ModelType : null; model = modelType == null || modelType == typeof(DynamicRequestObject) ? null : DeserializeHttpRequest(modelType, httpReq, httpReq.ContentType); } RazorFormat.ProcessRazorPage(httpReq, contentPage, model, httpRes); }
/// <summary> /// This is called by the hosting environment via CatchAll usually for content pages. /// </summary> public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { httpRes.ContentType = ContentType.Html; ResolveAndExecuteRazorPage(httpReq, httpRes, null); httpRes.EndRequest(skipHeaders: true); }
public PollServiceHttpRequest(PollServiceEventArgs pPollServiceArgs, IHttpClientContext pHttpContext, IHttpRequest pRequest) { PollServiceArgs = pPollServiceArgs; HttpContext = pHttpContext; Request = pRequest; RequestTime = System.Environment.TickCount; }
public static string CreateTemporarySessionId(this IHttpResponse res, IHttpRequest req) { var sessionId = Convert.ToBase64String(Guid.NewGuid().ToByteArray()); res.Cookies.AddSessionCookie(SessionFeature.SessionId, sessionId); req.Items[SessionFeature.SessionId] = sessionId; return sessionId; }
public override object GetResponse(IHttpRequest httpReq, object request) { var response = ExecuteService(request, HandlerAttributes | GetEndpointAttributes(httpReq), httpReq); return response; }
/// <summary> /// Create the active Session or Permanent Session Id cookie. /// </summary> /// <returns></returns> public static string CreateSessionId(this IHttpResponse res, IHttpRequest req) { var sessionOptions = GetSessionOptions(req); return sessionOptions.Contains(SessionOptions.Permanent) ? res.CreatePermanentSessionId(req) : res.CreateTemporarySessionId(req); }
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto) { var applicationRequest = requestDto as ApplicationRequest; var appKey = GetAppKeyFromRequest(req, applicationRequest); var appSecret = GetAppSecretFromRequest(req, applicationRequest); var app = ApplicationAuthenticationService.Authenticate(appKey,appSecret); if (app == null) { res.StatusCode = (int)HttpStatusCode.Forbidden; // Some Android devices require a body, otherwise the response code is ignored and set 0 res.Write(HttpStatusCode.Forbidden.ToString()); res.Close(); } if (applicationRequest != null) { applicationRequest.AppKey = appKey; applicationRequest.AppSecret = appSecret; applicationRequest.Application = ApplicationRepository.FindApplication(appKey, appSecret); applicationRequest.Account = AccountApplicationRepository.GetForApplication(applicationRequest.Application.Id); } var validationErrors = ValidateRequest(applicationRequest); if (validationErrors.Any()) { res.StatusCode = (int)HttpStatusCode.BadRequest; // Some Android devices require a body, otherwise the response code is ignored and set 0 res.Write(HttpStatusCode.BadRequest.ToString()); foreach (var error in validationErrors) { res.Write(error); } res.Close(); } }
public object GetRequest(IHttpRequest httpReq, string operationName) { var operationType = GetOperationType(operationName); AssertOperationExists(operationName, operationType); return DeserializeContentType(operationType, httpReq, HandlerContentType); }
public static string GetQueryValue(IHttpRequest req, string name) { string value; if (req.QueryData.TryGetValue (name, out value)) return value; return string.Empty; }
/// <summary> /// 同步的请求方式 /// </summary> /// <param name="request">请求的参数</param> /// <returns>自定义的Response结果</returns> public IHttpResponse ExecuteSync(IHttpRequest request) { IHttpResponse response = new HttpResponse(); try { if (string.IsNullOrEmpty(request.AddressUrl) || request.HttpMothed == HttpMothed.None) { response.ResponseStatus = ResponseStatus.Error; response.ErrorException = new Exception("对不起,请求出错,请检查参数等设置(地址,请求方式等)!"); return response; } HttpWebRequest webrequest = ConfigureWebRequest(request); SendBodyDataSync(webrequest, request); GetResponse(webrequest, ref response); } catch (Exception ex) { response.ErrorException = ex; response.ResponseStatus = ResponseStatus.Error; } return response; }
public static Response<Servicio> Get(this Servicio request, Factory factory, IHttpRequest httpRequest) { return factory.Execute(proxy=>{ long? totalCount=null; var paginador= new Paginador(httpRequest); var predicate = PredicateBuilder.True<Servicio>(); var visitor = ReadExtensions.CreateExpression<Servicio>(); if(!request.Nombre.IsNullOrEmpty()){ predicate = predicate.AndAlso(q=> q.Nombre.Contains(request.Nombre)); } visitor.Where(predicate).OrderBy(f=>f.Nombre); if(paginador.PageNumber.HasValue) { visitor.Select(r=> Sql.Count(r.Id)); totalCount= proxy.Count(visitor); visitor.Select(); int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.ResponsePageSize; visitor.Limit(paginador.PageNumber.Value*rows, rows); } return new Response<Servicio>(){ Data=proxy.Get(visitor), TotalCount=totalCount }; }); }
public async Task <IHttpResponse> ParseContentValuesAsync( IApplication httpApp, IHttpRequest request, Func < CastDelegate, string[], Task <IHttpResponse> > onParsedContentValues) { if (!request.HasBody) { return(await BodyMissing("Body was not provided")); } var contentString = await request.ReadContentAsStringAsync(); if (contentString.IsNullOrWhiteSpace()) { return(await BodyMissing("JSON body content is empty")); } var bindConvert = new BindConvert(request, httpApp as HttpApplication); try { var contentJObject = Newtonsoft.Json.Linq.JObject.Parse(contentString); CastDelegate parser = (paramInfo, onParsed, onFailure) => { return(paramInfo .GetAttributeInterface <IBindJsonApiValue>() .ParseContentDelegate(contentJObject, contentString, bindConvert, paramInfo, httpApp, request, onParsed, onFailure)); }; var keys = contentJObject .Properties() .Select(jProperty => jProperty.Name) .ToArray(); return(await onParsedContentValues(parser, keys)); } catch (Newtonsoft.Json.JsonReaderException) { try { var contentJArray = Newtonsoft.Json.Linq.JArray.Parse(contentString); CastDelegate parser = (paramInfo, onParsed, onFailure) => { return(paramInfo .GetAttributeInterface <IBindJsonApiValue>() .ParseContentDelegate(contentJArray, contentString, bindConvert, paramInfo, httpApp, request, onParsed, onFailure)); }; var keys = new string[] { }; return(await onParsedContentValues(parser, keys)); } catch (Exception ex) { return(await BodyMissing(ex.Message)); } } catch (Exception ex) { return(await BodyMissing(ex.Message)); } Task <IHttpResponse> BodyMissing(string failureMessage) { CastDelegate emptyParser = (paramInfo, onParsed, onFailure) => { var key = paramInfo .GetAttributeInterface <IBindApiValue>() .GetKey(paramInfo) .ToLowerNullSafe(); var type = paramInfo.ParameterType; return(onFailure($"[{key}] could not be parsed ({failureMessage}).")); }; var exceptionKeys = new string[] { }; return(onParsedContentValues(emptyParser, exceptionKeys)); } }
/// <exception cref="Apache.Http.HttpException"></exception> protected internal virtual HttpHost DetermineProxy(HttpHost target, IHttpRequest request, HttpContext context) { return(null); }
public OSHttpRequest(IHttpClientContext context, IHttpRequest req) { _request = req; _context = context; if (null != req.Headers["content-encoding"]) { try { _contentEncoding = Encoding.GetEncoding(_request.Headers["content-encoding"]); } catch (Exception) { // ignore } } if (null != req.Headers["content-type"]) { _contentType = _request.Headers["content-type"]; } if (null != req.Headers["user-agent"]) { _userAgent = req.Headers["user-agent"]; } if (null != req.Headers["remote_addr"]) { try { IPAddress addr = IPAddress.Parse(req.Headers["remote_addr"]); // sometimes req.Headers["remote_port"] returns a comma separated list, so use // the first one in the list and log it string[] strPorts = req.Headers["remote_port"].Split(new char[] { ',' }); if (strPorts.Length > 1) { _log.ErrorFormat("[OSHttpRequest]: format exception on addr/port {0}:{1}, ignoring", req.Headers["remote_addr"], req.Headers["remote_port"]); } int port = Int32.Parse(strPorts[0]); _remoteIPEndPoint = new IPEndPoint(addr, port); } catch (FormatException) { _log.ErrorFormat("[OSHttpRequest]: format exception on addr/port {0}:{1}, ignoring", req.Headers["remote_addr"], req.Headers["remote_port"]); } } _queryString = new NameValueCollection(); _query = new Hashtable(); try { foreach (HttpInputItem item in req.QueryString) { try { _queryString.Add(item.Name, item.Value); _query[item.Name] = item.Value; } catch (InvalidCastException) { _log.DebugFormat("[OSHttpRequest]: error parsing {0} query item, skipping it", item.Name); continue; } } } catch (Exception) { _log.ErrorFormat("[OSHttpRequest]: Error parsing querystring"); } // Form = new Hashtable(); // foreach (HttpInputItem item in req.Form) // { // _log.DebugFormat("[OSHttpRequest]: Got form item {0}={1}", item.Name, item.Value); // Form.Add(item.Name, item.Value); // } }
public IHttpResponse DoRegister(IHttpRequest request) { var username = request.FormData["username"].ToString().Trim(); var password = request.FormData["password"].ToString(); var confirmPassword = request.FormData["confirmPassword"].ToString(); var email = request.FormData["email"].ToString().Trim(); //Validate if (string.IsNullOrWhiteSpace(username) || username.Length < 3) { return(this.BadRequestError("Please provide valid username with length of 3 or more characters.")); } if (this.dbContext.Users.Any(x => x.Username == username)) { return(this.BadRequestError("User with the same name already exists.")); } if (string.IsNullOrWhiteSpace(password) || password.Length < 2) { return(this.BadRequestError("Please provide password of length 2 or more.")); } if (password != confirmPassword) { return(this.BadRequestError("Passwords do not match.")); } if (this.dbContext.Users.Any(x => x.Email.ToLower() == email.ToLower())) { return(this.BadRequestError("User with the same email already exists.")); } if (string.IsNullOrWhiteSpace(email)) { return(this.BadRequestError("Please provide valid email.")); } //Hash password var hashedPassword = this.hashSevice.Hash(password); //Create user var user = new User { Username = username, Password = hashedPassword, Email = email }; this.dbContext.Users.Add(user); try { this.dbContext.SaveChanges(); } catch (Exception e) { Console.WriteLine(e.Message); } return(new RedirectResult("/")); }
public AdminController(IHttpRequest request) : base(request) { this.gameService = new GameService(); }
public static void SetHttpRequest(IHttpRequest httpRequest) { ((HttpContextProvider)Instance)._httpRequest = httpRequest; }
public static void SetHttpRequest(IHttpRequest httpRequest) { HttpContextProvider.SetHttpRequest(httpRequest); }
/// <summary> /// Gets the auth. /// </summary> /// <param name="httpReq">The HTTP req.</param> /// <returns>Dictionary{System.StringSystem.String}.</returns> public static Dictionary <string, string> GetAuthorization(IHttpRequest httpReq) { var auth = httpReq.Headers[HttpHeaders.Authorization]; return(GetAuthorization(auth)); }
private void LogInUser(IHttpRequest req, string username) { req.Session.Add(SessionStore.CurrentUserKey, username); req.Session.Add(ShoppingCart.SessionKey, new ShoppingCart()); }
public bool DoesParse(IHttpRequest request) { return(request.IsJson()); }
public virtual void OnFailedAuthentication(IAuthSession session, IHttpRequest httpReq, IHttpResponse httpRes) { httpRes.StatusCode = (int)HttpStatusCode.Unauthorized; httpRes.AddHeader(HttpHeaders.WwwAuthenticate, "{0} realm=\"{1}\"".Fmt(this.Provider, this.AuthRealm)); httpRes.EndRequest(); }
public IHttpResponse Logout(IHttpRequest request) { request.Session.Clear(); return(new RedirectResponse("/login")); }
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto) { }
/// <summary>Creates a request.</summary> /// /// <param name="request"> The request.</param> /// <param name="operationName">Name of the operation.</param> /// /// <returns>The new request.</returns> public override object CreateRequest(IHttpRequest request, string operationName) { return(GetRequest(request, operationName)); }
public static int DetermineVersion(IHttpRequest request) { string dummy; return(request.Headers.TryGetValue("sec-websocket-key1", out dummy) && request.Headers.TryGetValue("sec-websocket-key2", out dummy) ? 76 : 75); }
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { var responseContentType = EndpointHost.Config.DefaultContentType; try { if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes)) { return; } var restPath = GetRestPath(httpReq.HttpMethod, httpReq.PathInfo); if (restPath == null) { throw new NotSupportedException("No RestPath found for: " + httpReq.HttpMethod + " " + httpReq.PathInfo); } operationName = restPath.RequestType.Name; var callback = httpReq.GetJsonpCallback(); var doJsonp = EndpointHost.Config.AllowJsonpRequests && !string.IsNullOrEmpty(callback); responseContentType = httpReq.ResponseContentType; EndpointHost.Config.AssertContentType(responseContentType); var request = GetRequest(httpReq, restPath); if (EndpointHost.ApplyRequestFilters(httpReq, httpRes, request)) { return; } var response = GetResponse(httpReq, httpRes, request); if (EndpointHost.ApplyResponseFilters(httpReq, httpRes, response)) { return; } if (responseContentType.Contains("jsv") && !string.IsNullOrEmpty(httpReq.QueryString["debug"])) { JsvSyncReplyHandler.WriteDebugResponse(httpRes, response); return; } if (doJsonp && !(response is CompressedResult)) { httpRes.WriteToResponse(httpReq, response, (callback + "(").ToUtf8Bytes(), ")".ToUtf8Bytes()); } else { httpRes.WriteToResponse(httpReq, response); } } catch (Exception ex) { if (!EndpointHost.Config.WriteErrorsToResponse) { throw; } HandleException(httpReq, httpRes, operationName, ex); } }
public override void Execute(IHttpRequest req, IHttpResponse res, object responseDto) { var dto = responseDto as AttributeFilteredResponse; dto.ContextualResponseFilterExecuted = true; }
public virtual Task <IHttpResponse> InstigatorDelegateGeneric(Type type, IApplication httpApp, IHttpRequest request, ParameterInfo parameterInfo, Func <object, Task <IHttpResponse> > onSuccess) { return(type .GetConstructors(BindingFlags.Public | BindingFlags.Instance) .First() .GetParameters() .Aggregate <ParameterInfo, Func <object[], Task <IHttpResponse> > >( (invocationParameterValues) => { var requestMessage = Activator.CreateInstance(type, invocationParameterValues); return onSuccess(requestMessage); }, (next, invocationParameterInfo) => { return (previousParams) => { return httpApp.Instigate(request, invocationParameterInfo, (invocationParameterValue) => { return next(previousParams.Prepend(invocationParameterValue).ToArray()); }); }; }) .Invoke(new object[] { })); }
public static bool Check(this IHttpRequest request, string uri) { return(request.Uri.ToString() == uri); }
public IHttpResponse FinishOrder(IHttpRequest request) { request.Session.Get <ShoppingCart>(ShoppingCart.SessionKey).Orders.Clear(); return(this.FileViewResponse(@"shopping\finish-order")); }
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 f***s 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); } } }
public void ResponseFilter(IHttpRequest req, IHttpResponse res, object responseDto) { var dto = responseDto as AttributeFilteredResponse; dto.ResponseFilterExecuted = true; }
/// <summary> /// Handle authentication /// </summary> /// <param name="request"></param> /// <param name="response"></param> /// <param name="session"></param> /// <returns>true if request can be handled; false if not.</returns> /// <exception cref="BadRequestException">Invalid authorization header</exception> protected virtual bool ProcessAuthentication(IHttpRequest request, IHttpResponse response, IHttpSession session) { if (_authModules.Count > 0) { bool authenticate = false; object authTag = null; if (request.Headers["authorization"] != null) { authenticate = true; string authHeader = request.Headers["authorization"]; int pos = authHeader.IndexOf(' '); if (pos == -1) { throw new BadRequestException("Invalid authorization header"); } // first word identifies the type of authentication to use. string word = authHeader.Substring(0, pos).ToLower(); // find the mod to use. AuthenticationModule mod = null; lock (_authModules) { foreach (AuthenticationModule aModule in _authModules) { if (aModule.Name != word) { continue; } mod = aModule; break; } } if (mod != null) { authTag = mod.Authenticate(authHeader, GetRealm(request), request.Method); session[AuthenticationModule.AuthenticationTag] = authTag; } } // Check if auth is needed. if (authTag == null) { lock (_authModules) { foreach (AuthenticationModule module in _authModules) { if (!module.AuthenticationRequired(request)) { continue; } RequestAuthentication(module, request, response); return(false); } // modules can have inited the authentication // and then the module.AuthenticationRequired method will not have been used. if (authenticate && _authModules.Count > 0) { RequestAuthentication(_authModules[0], request, response); return(false); } } } } return(true); }
// Entry point for HttpListener and .NET Core public static IHttpHandler GetHandler(IHttpRequest httpReq) { var appHost = HostContext.AppHost; foreach (var rawHttpHandler in appHost.RawHttpHandlers) { var handler = rawHttpHandler(httpReq); if (handler != null) { return(handler); } } var mode = appHost.Config.HandlerFactoryPath; var pathInfo = httpReq.PathInfo; //Default Request / if (string.IsNullOrEmpty(pathInfo) || pathInfo == "/") { //If the fallback route can handle it, let it if (appHost.Config.FallbackRestPath != null) { string contentType; var sanitizedPath = RestHandler.GetSanitizedPathInfo(pathInfo, out contentType); var restPath = appHost.Config.FallbackRestPath(httpReq.HttpMethod, sanitizedPath, httpReq.GetPhysicalPath()); if (restPath != null) { return(new RestHandler { RestPath = restPath, RequestName = restPath.RequestType.GetOperationName(), ResponseContentType = contentType }); } } //e.g. CatchAllHandler to Process Markdown files var catchAllHandler = GetCatchAllHandlerIfAny(httpReq.HttpMethod, pathInfo, httpReq.GetPhysicalPath()); if (catchAllHandler != null) { return(catchAllHandler); } if (mode == null) { return(DefaultHttpHandler); } if (DefaultRootFileName != null) { return(StaticFilesHandler); } return(NonRootModeDefaultHttpHandler); } if (mode != null && pathInfo.EndsWith("/" + mode)) { return(ReturnDefaultHandler(httpReq)); } return(GetHandlerForPathInfo(httpReq, httpReq.GetPhysicalPath()) ?? NotFoundHttpHandler); }
/// <summary> /// Realms are used by the <see cref="AuthenticationModule"/>s. /// </summary> /// <param name="request">HTTP request</param> /// <returns>domain/realm.</returns> protected virtual string GetRealm(IHttpRequest request) { return(RealmWanted != null?RealmWanted(request.Headers["host"] ?? "localhost") : ServerName); }
/// <summary> /// To be able to track request count. /// </summary> /// <param name="context"></param> /// <param name="request"></param> private void ProcessRequestWrapper(IHttpClientContext context, IHttpRequest request) { _requestQueue.CurrentRequestCount += 1; ProcessRequest(context, request); _requestQueue.CurrentRequestCount -= 1; }
public IHttpResponse Register(IHttpRequest request) { return(this.View("Register")); }
/// <summary> /// Process an incoming request. /// </summary> /// <param name="context">connection to client</param> /// <param name="request">request information</param> /// <param name="response">response that should be filled</param> /// <param name="session">session information</param> protected virtual void HandleRequest(IHttpClientContext context, IHttpRequest request, IHttpResponse response, IHttpSession session) { _logWriter.Write(this, LogPrio.Trace, "Processing request...."); bool handled = false; try { DecodeBody(request); if (ProcessAuthentication(request, response, session)) { foreach (HttpModule module in _modules) { if (!module.Process(request, response, session)) { continue; } handled = true; if (!module.AllowSecondaryProcessing) { break; } } } } catch (HttpException err) { if (err.HttpStatusCode == HttpStatusCode.Unauthorized) { AuthenticationModule mod; lock (_authModules) mod = _authModules.Count > 0 ? _authModules[0] : null; if (mod != null) { RequestAuthentication(mod, request, response); } } else { ErrorPage(response, err); } } if (!handled && response.Status == HttpStatusCode.OK) { ErrorPage(response, HttpStatusCode.NotFound, "Resource not found: " + request.Uri); } if (!response.HeadersSent) { // Dispose session if it was not used. if (session.Count > 0) { _sessionStore.Save(session); // only set session cookie if it have not been sent in the request. if (request.Cookies[_sessionCookieName] == null) { response.Cookies.Add(new ResponseCookie(_sessionCookieName, session.Id, DateTime.MinValue)); //DateTime.Now.AddMinutes(20).AddDays(1))); } } else { _sessionStore.AddUnused(session); } } if (!response.Sent) { response.Send(); } _logWriter.Write(this, LogPrio.Trace, "....done."); }
protected bool IsAuthenticated(IHttpRequest request) { return(request.Session.ContainsParameter("username")); }
public IHttpResponse Login(IHttpRequest request) { return(this.View("Login")); }