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;
        }
Example #6
0
        /// <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);
        }
Example #7
0
        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;
        }
Example #11
0
 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);
        }
Example #14
0
		public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request)
		{
			var response = ExecuteService(request,
                HandlerAttributes | httpReq.GetAttributes(), httpReq, httpRes);
			
			return response;
		}
Example #15
0
		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);
			}
		}
Example #16
0
        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);
        }
Example #18
0
        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);
        }
Example #20
0
        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);
        }
Example #21
0
        /// <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);
        }
Example #22
0
 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;
 }
Example #24
0
        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();
            }
        }
Example #27
0
        public object GetRequest(IHttpRequest httpReq, string operationName)
        {
            var operationType = GetOperationType(operationName);
            AssertOperationExists(operationName, operationType);

            return DeserializeContentType(operationType, httpReq, HandlerContentType);
        }
Example #28
0
 public static string GetQueryValue(IHttpRequest req, string name)
 {
     string value;
     if (req.QueryData.TryGetValue (name, out value))
         return value;
     return string.Empty;
 }
Example #29
0
        /// <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);
//            }
        }
Example #34
0
        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();
 }
Example #36
0
 public static void SetHttpRequest(IHttpRequest httpRequest)
 {
     ((HttpContextProvider)Instance)._httpRequest = httpRequest;
 }
Example #37
0
 public static void SetHttpRequest(IHttpRequest httpRequest)
 {
     HttpContextProvider.SetHttpRequest(httpRequest);
 }
Example #38
0
        /// <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());
 }
Example #41
0
 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"));
        }
Example #43
0
 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));
 }
Example #45
0
        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);
        }
Example #46
0
        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);
            }
        }
Example #47
0
        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[] { }));
 }
Example #49
0
 public static bool Check(this IHttpRequest request, string uri)
 {
     return(request.Uri.ToString() == uri);
 }
Example #50
0
        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);
                }
            }
        }
Example #52
0
        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;
 }
Example #57
0
 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.");
        }
Example #59
0
 protected bool IsAuthenticated(IHttpRequest request)
 {
     return(request.Session.ContainsParameter("username"));
 }
Example #60
0
 public IHttpResponse Login(IHttpRequest request)
 {
     return(this.View("Login"));
 }