.net core , how to handle route with extra leading slash

Question

I need to handle an incoming request which is of the form: //ohif/study/1.1/series Note the exta slash at the front

My controller signature is:

[Route("ohif/study/{studyUid}/series")]
[HttpGet]
public IActionResult GetStudy(string studyUid)

If I modify the incoming request to /ohif/study/1.1/series it works fine

however when I use //ohif/study/1.1/series, the route is not hit

Additionally I also tried: [Route("/ohif/study/{studyUid}/series")] and [Route("//ohif/study/{studyUid}/series")]

Both fail. I unfortunately cannot change the incoming request as it is from an external application. Is there some trick to handle this route? I am working in .NET Core 3.0.

Update NOTE: I have logging activated and I see that asp.net core is analyzing the route, I have the message: No candidates found for the request path '//ohif/study/1.1/series' for the logger Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware

maybe you can try and override controllers, onactionexecuting method and apply some logic there — Muhammad Kamran Aslam, Dec 12 '19 at 12:08
`Route("ohif/study/{studyUid:regex(^(\\d*\\.)?\\d+(?!.\\\\series))}")` possibly something like that. I have no way to test it. — Felix Castor, Dec 12 '19 at 13:32
@FelixCastor that regex is handling slashes at the end the issue is really the extra slash "/" at the start of the url, I will try some regexes and provide feedback — shelbypereira, Dec 12 '19 at 13:51
doh, Yeah, I thought the slash at the end was the problem... — Felix Castor, Dec 15 '19 at 17:44

score 9 · Answer 1 · answered Apr 26 '20 at 15:13

9

What about the middleware to handle double slash?

app.Use((context, next) =>
            {
                if (context.Request.Path.Value.StartsWith("//"))
                {
                    context.Request.Path = new PathString(context.Request.Path.Value.Replace("//", "/"));
                }
                return next();
            });

answered Apr 26 '20 at 15:13

Ravi

398
3
11

When I looked up this middleware approach in the MS documentation they had it with async. `app.Use( async ( context, next ) => { var path = context.Request.Path.Value; /* do something */ await next.Invoke(); });` – StackOverflowUser Feb 10 '23 at 20:35
In .Net 6, app.UseRouting() can be implicit, and if so will be at the start of the pipeline so this won't appear to work. Add an explicit UseRouting() call after the above. More details here https://stackoverflow.com/a/59966192/960380 – LMK May 23 '23 at 02:09

score 4 · Accepted Answer · answered Dec 12 '19 at 15:25

4

Rewrite the URL at the web server-level, e.g. for IIS, you can use the URL Rewrite Module to automatically redirect //ohif/study/1.1/series to /ohif/study/1.1/series. This isn't a job for your application.

answered Dec 12 '19 at 15:25

Chris Pratt

232,153
36
385
444

I think this is the correct approach, I also found a quick workaround using route constraints with a catchall route as described here https://stackoverflow.com/questions/22664924/net-mvc-routing-catchall-at-start-of-route – shelbypereira Dec 13 '19 at 06:58
That will make it fun when you migrate your app elsewhere and you forget. – LMK May 23 '23 at 02:11

Jess · Answer 3 · 2022-09-27T15:00:11.630

I took Ravi's answer and fleshed out a middleware. The middleware is nice because it is encapsulated, easily testable, can inject a logger, more readable, etc.

app.UseDoubleSlashHandler();

The code and tests:

public class DoubleSlashMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<DoubleSlashMiddleware> _logger;

    public DoubleSlashMiddleware(RequestDelegate next, ILogger<DoubleSlashMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation($"Invoking {nameof(DoubleSlashMiddleware)} on {context.Request.Path}");

        context.Request.Path = context.Request.Path.FixDoubleSlashes();

        // Call the next delegate/middleware in the pipeline.
        await _next(context);
    }
}

public static class DoubleSlashMiddlewareExtensions
{
    public static IApplicationBuilder UseDoubleSlashHandler(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<DoubleSlashMiddleware>();
    }
}

[TestClass()]
public class DoubleSlashMiddlewareTests
{
    private DoubleSlashMiddleware _sut;
    private ILogger<DoubleSlashMiddleware> _logger;
    private bool _calledNextMiddlewareInPipeline;

    [TestInitialize()]
    public void TestInitialize()
    {
        _logger = Substitute.For<ILogger<DoubleSlashMiddleware>>();
        Task Next(HttpContext _)
        {
            _calledNextMiddlewareInPipeline = true;
            return Task.CompletedTask;
        }
        _sut = new DoubleSlashMiddleware(Next, _logger);
    }

    [TestMethod()]
    public async Task InvokeAsync()
    {
        // Arrange
        _calledNextMiddlewareInPipeline = false;

        // Act
        await _sut.InvokeAsync(new DefaultHttpContext());

        // Assert
        _logger.ReceivedWithAnyArgs(1).LogInformation(null);
        Assert.IsTrue(_calledNextMiddlewareInPipeline);
    }
}

String method to do the replacement:

public static class RoutingHelper
{
    public static PathString FixDoubleSlashes(this PathString path)
    {
        if (string.IsNullOrWhiteSpace(path.Value))
        {
            return path;
        }
        if (path.Value.Contains("//"))
        {
            return new PathString(path.Value.Replace("//", "/"));
        }
        return path;
    }
}

[TestClass()]
public class RoutingHelperTests
{
    [TestMethod()]
    [DataRow(null, null)]
    [DataRow("", "")]
    [DataRow("/connect/token", "/connect/token")]
    [DataRow("//connect/token", "/connect/token")]
    [DataRow("/connect//token", "/connect/token")]
    [DataRow("//connect//token", "/connect/token")]
    [DataRow("/connect///token", "/connect/token")]
    public void FixDoubleSlashes(string input, string expected)
    {
        // Arrange
        var path = new PathString(input);

        // Act
        var actual = path.FixDoubleSlashes();

        // Assert
        Assert.AreEqual(expected, actual.Value);
    }
}

This is certainly more code, but do you really want untested code in your startup that is executed for every request? (with no logging) ;) — Jess, Sep 13 '22 at 13:21
Here's one more test case: [DataRow("/connect///token", "/connect/token")] — Christof Wollenhaupt, Sep 27 '22 at 14:48

.net core , how to handle route with extra leading slash

3 Answers3

Linked

Related