public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(PathSetKey, out var pathSet))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var path = MakePathString(pathSet);
context.AddPathSet(path);
}
else if (transformValues.TryGetValue(PathPrefixKey, out var pathPrefix))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var path = MakePathString(pathPrefix);
context.AddPathPrefix(path);
}
else if (transformValues.TryGetValue(PathRemovePrefixKey, out var pathRemovePrefix))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var path = MakePathString(pathRemovePrefix);
context.AddPathRemovePrefix(path);
}
else if (transformValues.TryGetValue(PathPatternKey, out var pathPattern))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var path = MakePathString(pathPattern);
// We don't use the extension here because we want to avoid doing a DI lookup for the binder every time.
context.RequestTransforms.Add(new PathRouteValuesTransform(path.Value !, _binderFactory));
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(RequestHeadersCopyKey, out var copyHeaders))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.CopyRequestHeaders = bool.Parse(copyHeaders);
}
else if (transformValues.TryGetValue(RequestHeaderOriginalHostKey, out var originalHost))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.AddOriginalHost(bool.Parse(originalHost));
}
else if (transformValues.TryGetValue(RequestHeaderKey, out var headerName))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
if (transformValues.TryGetValue(SetKey, out var setValue))
{
context.AddRequestHeader(headerName, setValue, append: false);
}
else if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
context.AddRequestHeader(headerName, appendValue, append: true);
}
else
{
throw new ArgumentException($"Unexpected parameters for RequestHeader: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'");
}
}
else if (transformValues.TryGetValue(RequestHeaderRemoveKey, out var removeHeaderName))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.AddRequestHeaderRemove(removeHeaderName);
}
else if (transformValues.TryGetValue(RequestHeadersAllowedKey, out var allowedHeaders))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var headersList = allowedHeaders.Split(';', options: StringSplitOptions.RemoveEmptyEntries
#if NET
| StringSplitOptions.TrimEntries
#endif
);
context.AddRequestHeadersAllowed(headersList);
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(QueryValueParameterKey, out var queryValueParameter))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
context.AddQueryValue(queryValueParameter, appendValue, append: true);
}
else if (transformValues.TryGetValue(SetKey, out var setValue))
{
context.AddQueryValue(queryValueParameter, setValue, append: false);
}
else
{
throw new NotSupportedException(string.Join(";", transformValues.Keys));
}
}
else if (transformValues.TryGetValue(QueryRouteParameterKey, out var queryRouteParameter))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
if (transformValues.TryGetValue(AppendKey, out var routeValueKeyAppend))
{
context.AddQueryRouteValue(queryRouteParameter, routeValueKeyAppend, append: true);
}
else if (transformValues.TryGetValue(SetKey, out var routeValueKeySet))
{
context.AddQueryRouteValue(queryRouteParameter, routeValueKeySet, append: false);
}
else
{
throw new NotSupportedException(string.Join(";", transformValues.Keys));
}
}
else if (transformValues.TryGetValue(QueryRemoveParameterKey, out var removeQueryParameter))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.AddQueryRemoveKey(removeQueryParameter);
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(HttpMethodChangeKey, out var fromHttpMethod))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
if (transformValues.TryGetValue(SetKey, out var toHttpMethod))
{
context.AddHttpMethodChange(fromHttpMethod, toHttpMethod);
}
}
else
{
return(false);
}
return(true);
}
public bool Validate(TransformRouteValidationContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(HttpMethodChangeKey, out var _))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
if (!transformValues.TryGetValue(SetKey, out var _))
{
context.Errors.Add(new ArgumentException($"Unexpected parameters for HttpMethod: {string.Join(';', transformValues.Keys)}. Expected 'Set'"));
}
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(XForwardedKey, out var xforwardedHeaders))
{
var expected = 1;
var append = true;
if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
expected++;
append = bool.Parse(appendValue);
}
var prefix = "X-Forwarded-";
if (transformValues.TryGetValue(PrefixForwardedKey, out var prefixValue))
{
expected++;
prefix = prefixValue;
}
TransformHelpers.CheckTooManyParameters(transformValues, expected);
// for, host, proto, Prefix
var tokens = xforwardedHeaders.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
bool useFor, useHost, useProto, usePrefix;
useFor = useHost = useProto = usePrefix = false;
foreach (var token in tokens)
{
if (string.Equals(token, ForKey, StringComparison.OrdinalIgnoreCase))
{
useFor = true;
}
else if (string.Equals(token, HostKey, StringComparison.OrdinalIgnoreCase))
{
useHost = true;
}
else if (string.Equals(token, ProtoKey, StringComparison.OrdinalIgnoreCase))
{
useProto = true;
}
else if (string.Equals(token, PrefixKey, StringComparison.OrdinalIgnoreCase))
{
usePrefix = true;
}
else
{
throw new ArgumentException($"Unexpected value for X-Forwarded: {token}. Expected 'for', 'host', 'proto', or 'Prefix'");
}
}
context.AddXForwarded(prefix, useFor, useHost, useProto, usePrefix, append);
}
else if (transformValues.TryGetValue(ForwardedKey, out var forwardedHeader))
{
var useHost = false;
var useProto = false;
var useFor = false;
var useBy = false;
var forFormat = NodeFormat.None;
var byFormat = NodeFormat.None;
// for, host, proto, Prefix
var tokens = forwardedHeader.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var token in tokens)
{
if (string.Equals(token, ForKey, StringComparison.OrdinalIgnoreCase))
{
useFor = true;
forFormat = NodeFormat.Random; // RFC Default
}
else if (string.Equals(token, ByKey, StringComparison.OrdinalIgnoreCase))
{
useBy = true;
byFormat = NodeFormat.Random; // RFC Default
}
else if (string.Equals(token, HostKey, StringComparison.OrdinalIgnoreCase))
{
useHost = true;
}
else if (string.Equals(token, ProtoKey, StringComparison.OrdinalIgnoreCase))
{
useProto = true;
}
else
{
throw new ArgumentException($"Unexpected value for X-Forwarded: {token}. Expected 'for', 'host', 'proto', or 'by'");
}
}
var expected = 1;
var append = true;
if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
expected++;
append = bool.Parse(appendValue);
}
if (useFor && transformValues.TryGetValue(ForFormatKey, out var forFormatString))
{
expected++;
forFormat = Enum.Parse <NodeFormat>(forFormatString, ignoreCase: true);
}
if (useBy && transformValues.TryGetValue(ByFormatKey, out var byFormatString))
{
expected++;
byFormat = Enum.Parse <NodeFormat>(byFormatString, ignoreCase: true);
}
TransformHelpers.CheckTooManyParameters(transformValues, expected);
context.UseDefaultForwarders = false;
if (useBy || useFor || useHost || useProto)
{
// Not using the extension to avoid resolving the random factory each time.
context.RequestTransforms.Add(new RequestHeaderForwardedTransform(_randomFactory, forFormat, byFormat, useHost, useProto, append));
}
}
else if (transformValues.TryGetValue(ClientCertKey, out var clientCertHeader))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.AddClientCertHeader(clientCertHeader);
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(ResponseHeadersCopyKey, out var copyHeaders))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.CopyResponseHeaders = bool.Parse(copyHeaders);
}
else if (transformValues.TryGetValue(ResponseTrailersCopyKey, out copyHeaders))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.CopyResponseTrailers = bool.Parse(copyHeaders);
}
else if (transformValues.TryGetValue(ResponseHeaderKey, out var responseHeaderName))
{
var always = false;
if (transformValues.TryGetValue(WhenKey, out var whenValue))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 3);
always = string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase);
}
else
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
}
if (transformValues.TryGetValue(SetKey, out var setValue))
{
context.AddResponseHeader(responseHeaderName, setValue, append: false, always);
}
else if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
context.AddResponseHeader(responseHeaderName, appendValue, append: true, always);
}
else
{
throw new ArgumentException($"Unexpected parameters for ResponseHeader: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'");
}
}
else if (transformValues.TryGetValue(ResponseTrailerKey, out var responseTrailerName))
{
var always = false;
if (transformValues.TryGetValue(WhenKey, out var whenValue))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 3);
always = string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase);
}
else
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
}
if (transformValues.TryGetValue(SetKey, out var setValue))
{
context.AddResponseTrailer(responseTrailerName, setValue, append: false, always);
}
else if (transformValues.TryGetValue(AppendKey, out var appendValue))
{
context.AddResponseTrailer(responseTrailerName, appendValue, append: true, always);
}
else
{
throw new ArgumentException($"Unexpected parameters for ResponseTrailer: {string.Join(';', transformValues.Keys)}. Expected 'Set' or 'Append'");
}
}
else if (transformValues.TryGetValue(ResponseHeaderRemoveKey, out var removeResponseHeaderName))
{
var always = false;
if (transformValues.TryGetValue(WhenKey, out var whenValue))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
always = string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase);
}
else
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
}
context.AddResponseHeaderRemove(removeResponseHeaderName, always);
}
else if (transformValues.TryGetValue(ResponseTrailerRemoveKey, out var removeResponseTrailerName))
{
var always = false;
if (transformValues.TryGetValue(WhenKey, out var whenValue))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 2);
always = string.Equals(AlwaysValue, whenValue, StringComparison.OrdinalIgnoreCase);
}
else
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
}
context.AddResponseTrailerRemove(removeResponseTrailerName, always);
}
else if (transformValues.TryGetValue(ResponseHeadersAllowedKey, out var allowedHeaders))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var headersList = allowedHeaders.Split(';', options: StringSplitOptions.RemoveEmptyEntries
#if NET
| StringSplitOptions.TrimEntries
#endif
);
context.AddResponseHeadersAllowed(headersList);
}
else if (transformValues.TryGetValue(ResponseTrailersAllowedKey, out var allowedTrailers))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
var headersList = allowedTrailers.Split(';', options: StringSplitOptions.RemoveEmptyEntries
#if NET
| StringSplitOptions.TrimEntries
#endif
);
context.AddResponseTrailersAllowed(headersList);
}
else
{
return(false);
}
return(true);
}
public bool Build(TransformBuilderContext context, IReadOnlyDictionary <string, string> transformValues)
{
if (transformValues.TryGetValue(XForwardedKey, out var headerValue))
{
var xExpected = 1;
var defaultXAction = Enum.Parse <ForwardedTransformActions>(headerValue);
var prefix = DefaultXForwardedPrefix;
if (transformValues.TryGetValue(HeaderPrefixKey, out var prefixValue))
{
xExpected++;
prefix = prefixValue;
}
var xForAction = defaultXAction;
if (transformValues.TryGetValue(ForKey, out headerValue))
{
xExpected++;
xForAction = Enum.Parse <ForwardedTransformActions>(headerValue);
}
var xPrefixAction = defaultXAction;
if (transformValues.TryGetValue(PrefixKey, out headerValue))
{
xExpected++;
xPrefixAction = Enum.Parse <ForwardedTransformActions>(headerValue);
}
var xHostAction = defaultXAction;
if (transformValues.TryGetValue(HostKey, out headerValue))
{
xExpected++;
xHostAction = Enum.Parse <ForwardedTransformActions>(headerValue);
}
var xProtoAction = defaultXAction;
if (transformValues.TryGetValue(ProtoKey, out headerValue))
{
xExpected++;
xProtoAction = Enum.Parse <ForwardedTransformActions>(headerValue);;
}
TransformHelpers.CheckTooManyParameters(transformValues, xExpected);
context.AddXForwardedFor(prefix + ForKey, xForAction);
context.AddXForwardedPrefix(prefix + PrefixKey, xPrefixAction);
context.AddXForwardedHost(prefix + HostKey, xHostAction);
context.AddXForwardedProto(prefix + ProtoKey, xProtoAction);
if (xForAction != ForwardedTransformActions.Off || xPrefixAction != ForwardedTransformActions.Off ||
xHostAction != ForwardedTransformActions.Off || xProtoAction != ForwardedTransformActions.Off)
{
// Remove the Forwarded header when an X-Forwarded transform is enabled
TransformHelpers.RemoveForwardedHeader(context);
}
}
else if (transformValues.TryGetValue(ForwardedKey, out var forwardedHeader))
{
var useHost = false;
var useProto = false;
var useFor = false;
var useBy = false;
var forFormat = NodeFormat.None;
var byFormat = NodeFormat.None;
// for, host, proto, Prefix
var tokens = forwardedHeader.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var token in tokens)
{
if (string.Equals(token, ForKey, StringComparison.OrdinalIgnoreCase))
{
useFor = true;
forFormat = NodeFormat.Random; // RFC Default
}
else if (string.Equals(token, ByKey, StringComparison.OrdinalIgnoreCase))
{
useBy = true;
byFormat = NodeFormat.Random; // RFC Default
}
else if (string.Equals(token, HostKey, StringComparison.OrdinalIgnoreCase))
{
useHost = true;
}
else if (string.Equals(token, ProtoKey, StringComparison.OrdinalIgnoreCase))
{
useProto = true;
}
else
{
throw new ArgumentException($"Unexpected value for Forwarded: {token}. Expected 'for', 'host', 'proto', or 'by'");
}
}
var expected = 1;
var headerAction = ForwardedTransformActions.Set;
if (transformValues.TryGetValue(ActionKey, out headerValue))
{
expected++;
headerAction = Enum.Parse <ForwardedTransformActions>(headerValue);
}
if (useFor && transformValues.TryGetValue(ForFormatKey, out var forFormatString))
{
expected++;
forFormat = Enum.Parse <NodeFormat>(forFormatString, ignoreCase: true);
}
if (useBy && transformValues.TryGetValue(ByFormatKey, out var byFormatString))
{
expected++;
byFormat = Enum.Parse <NodeFormat>(byFormatString, ignoreCase: true);
}
TransformHelpers.CheckTooManyParameters(transformValues, expected);
context.UseDefaultForwarders = false;
if (headerAction != ForwardedTransformActions.Off && (useBy || useFor || useHost || useProto))
{
// Not using the extension to avoid resolving the random factory each time.
context.RequestTransforms.Add(new RequestHeaderForwardedTransform(_randomFactory, forFormat, byFormat, useHost, useProto, headerAction));
// Remove the X-Forwarded headers when an Forwarded transform is enabled
TransformHelpers.RemoveAllXForwardedHeaders(context, DefaultXForwardedPrefix);
}
}
else if (transformValues.TryGetValue(ClientCertKey, out var clientCertHeader))
{
TransformHelpers.CheckTooManyParameters(transformValues, expected: 1);
context.AddClientCertHeader(clientCertHeader);
}
else
{
return(false);
}
return(true);
}
