Example #1
0
        public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
        {
            if (transformValues.TryGetValue(RequestHeadersCopyKey, out var copyHeaders))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
                if (!bool.TryParse(copyHeaders, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected value for RequestHeaderCopy: {copyHeaders}. Expected 'true' or 'false'"));
                }
            }
            else if (transformValues.TryGetValue(RequestHeaderOriginalHostKey, out var originalHost))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
                if (!bool.TryParse(originalHost, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected value for RequestHeaderOriginalHost: {originalHost}. Expected 'true' or 'false'"));
                }
            }
            else if (transformValues.TryGetValue(RequestHeaderKey, out var _))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 2);
                if (!transformValues.TryGetValue(SetKey, out var _) && !transformValues.TryGetValue(AppendKey, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected parameters for RequestHeader: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'"));
                }
            }
            else
            {
                return(false);
            }

            return(true);
        }
Example #2
0
        public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
        {
            if (transformValues.TryGetValue(QueryValueParameterKey, out var queryValueParameter))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 2);
                if (!transformValues.TryGetValue(AppendKey, out var _) && !transformValues.TryGetValue(SetKey, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected parameters for QueryValueParameter: {string.Join(';', transformValues.Keys)}. Expected 'Append' or 'Set'."));
                }
            }
            else if (transformValues.TryGetValue(QueryRouteParameterKey, out var queryRouteParameter))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 2);
                if (!transformValues.TryGetValue(AppendKey, out var _) && !transformValues.TryGetValue(SetKey, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected parameters for QueryRouteParameter: {string.Join(';', transformValues.Keys)}. Expected 'Append' or 'Set'."));
                }
            }
            else if (transformValues.TryGetValue(QueryRemoveParameterKey, out var removeQueryParameter))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
            }
            else
            {
                return(false);
            }

            return(true);
        }
Example #3
0
        public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
        {
            if (transformValues.TryGetValue(PathSetKey, out var pathSet))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
            }
            else if (transformValues.TryGetValue(PathPrefixKey, out var pathPrefix))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
            }
            else if (transformValues.TryGetValue(PathRemovePrefixKey, out var pathRemovePrefix))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
            }
            else if (transformValues.TryGetValue(PathPatternKey, out var pathPattern))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
                // TODO: Validate the pattern format. Does it build?
            }
            else
            {
                return(false);
            }

            return(true);
        }
Example #4
0
        public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
        {
            if (transformValues.TryGetValue(ResponseHeadersCopyKey, out var copyHeaders))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
                if (!bool.TryParse(copyHeaders, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected value for ResponseHeadersCopy: {copyHeaders}. Expected 'true' or 'false'"));
                }
            }
            else if (transformValues.TryGetValue(ResponseTrailersCopyKey, out copyHeaders))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
                if (!bool.TryParse(copyHeaders, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected value for ResponseTrailersCopy: {copyHeaders}. Expected 'true' or 'false'"));
                }
            }
            else if (transformValues.TryGetValue(ResponseHeaderKey, out var _))
            {
                if (transformValues.TryGetValue(WhenKey, out var whenValue))
                {
                    TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 3);
                    if (!string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase) && !string.Equals(SuccessValue, whenValue, StringComparison.OrdinalIgnoreCase))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for ResponseHeader:When: {whenValue}. Expected 'Always' or 'Success'"));
                    }
                }
                else
                {
                    TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 2);
                }

                if (!transformValues.TryGetValue(SetKey, out var _) && !transformValues.TryGetValue(AppendKey, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected parameters for ResponseHeader: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'"));
                }
            }
            else if (transformValues.TryGetValue(ResponseTrailerKey, out var _))
            {
                if (transformValues.TryGetValue(WhenKey, out var whenValue))
                {
                    TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 3);
                    if (!string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase) && !string.Equals(SuccessValue, whenValue, StringComparison.OrdinalIgnoreCase))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for ResponseTrailer:When: {whenValue}. Expected 'Always' or 'Success'"));
                    }
                }
                else
                {
                    TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 2);
                }

                if (!transformValues.TryGetValue(SetKey, out var _) && !transformValues.TryGetValue(AppendKey, out var _))
                {
                    context.Errors.Add(new ArgumentException($"Unexpected parameters for ResponseTrailer: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'"));
                }
            }
            else
            {
                return(false);
            }

            return(true);
        }
Example #5
0
        public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
        {
            if (transformValues.TryGetValue(XForwardedKey, out var xforwardedHeaders))
            {
                var expected = 1;

                if (transformValues.TryGetValue(AppendKey, out var appendValue))
                {
                    expected++;
                    if (!bool.TryParse(appendValue, out var _))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for X-Forwarded:Append: {appendValue}. Expected 'true' or 'false'"));
                    }
                }

                if (transformValues.TryGetValue(PrefixKey, out var _))
                {
                    expected++;
                }

                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected);

                // for, host, proto, PathBase
                var tokens = xforwardedHeaders.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var token in tokens)
                {
                    if (!string.Equals(token, ForKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, HostKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, ProtoKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, PathBaseKey, StringComparison.OrdinalIgnoreCase))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for X-Forwarded: {token}. Expected 'for', 'host', 'proto', or 'PathBase'"));
                    }
                }
            }
            else if (transformValues.TryGetValue(ForwardedKey, out var forwardedHeader))
            {
                var expected = 1;

                if (transformValues.TryGetValue(AppendKey, out var appendValue))
                {
                    expected++;
                    if (!bool.TryParse(appendValue, out var _))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for Forwarded:Append: {appendValue}. Expected 'true' or 'false'"));
                    }
                }

                var enumValues = "Random,RandomAndPort,Unknown,UnknownAndPort,Ip,IpAndPort";
                if (transformValues.TryGetValue(ForFormatKey, out var forFormat))
                {
                    expected++;
                    if (!Enum.TryParse <NodeFormat>(forFormat, ignoreCase: true, out var _))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for Forwarded:ForFormat: {forFormat}. Expected: {enumValues}"));
                    }
                }

                if (transformValues.TryGetValue(ByFormatKey, out var byFormat))
                {
                    expected++;
                    if (!Enum.TryParse <NodeFormat>(byFormat, ignoreCase: true, out var _))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for Forwarded:ByFormat: {byFormat}. Expected: {enumValues}"));
                    }
                }

                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected);

                // for, host, proto, by
                var tokens = forwardedHeader.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var token in tokens)
                {
                    if (!string.Equals(token, ByKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, HostKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, ProtoKey, StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(token, ForKey, StringComparison.OrdinalIgnoreCase))
                    {
                        context.Errors.Add(new ArgumentException($"Unexpected value for X-Forwarded: {token}. Expected 'for', 'host', 'proto', or 'by'"));
                    }
                }
            }
            else if (transformValues.TryGetValue(ClientCertKey, out var clientCertHeader))
            {
                TransformHelpers.TryCheckTooManyParameters(context, transformValues, expected: 1);
            }
            else
            {
                return(false);
            }

            return(true);
        }