HTTP Redirect Limits: One Ouroboros, Six Languages

curl -sIL -A "wal-sh-test/curl" --max-redirs 100 https://wal.sh/ouroboros/a 2>&1 \
  | grep -c 'HTTP/' | xargs printf "curl (max-redirs 100): %s responses\n"
curl -sIL -A "wal-sh-test/curl-default" https://wal.sh/ouroboros/a 2>/dev/null \
  | grep -c 'HTTP/' | xargs printf "curl (default): %s responses\n"

import requests

try:
    r = requests.get("https://wal.sh/ouroboros/a",
                     allow_redirects=True,
                     headers={"User-Agent": "wal-sh-test/python-requests"})
    print(f"python requests: status {r.status_code} after {len(r.history)} redirects")
except requests.exceptions.TooManyRedirects as e:
    hist = e.response.history if e.response else []
    print(f"python requests: TooManyRedirects after {len(hist)} hops")
except Exception as e:
    print(f"python requests: {type(e).__name__}: {e}")

import urllib.request

req = urllib.request.Request("https://wal.sh/ouroboros/a",
                             headers={"User-Agent": "wal-sh-test/python-urllib"})
try:
    urllib.request.urlopen(req)
except urllib.error.HTTPError as e:
    print(f"python urllib: HTTPError {e.code}")
except Exception as e:
    print(f"python urllib: {type(e).__name__}: {e}")

try {
  const res = await fetch("https://wal.sh/ouroboros/a", {
    redirect: "follow",
    headers: { "User-Agent": "wal-sh-test/node-fetch" }
  });
  console.log(`node fetch: status ${res.status}`);
} catch (e) {
  console.log(`node fetch: ${e.constructor.name}: ${e.message}`);
}

try {
  const res = await fetch("https://wal.sh/ouroboros/a", {
    redirect: "follow",
    headers: { "User-Agent": "wal-sh-test/deno" }
  });
  console.log(`deno fetch: status ${res.status}`);
} catch (e) {
  console.log(`deno fetch: ${(e as Error).constructor.name}: ${(e as Error).message}`);
}

package main
import (
    "fmt"
    "net/http"
)
func main() {
    client := &http.Client{}
    req, _ := http.NewRequest("HEAD", "https://wal.sh/ouroboros/a", nil)
    req.Header.Set("User-Agent", "wal-sh-test/go")
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("go net/http: %T: %v\n", err, err)
        return
    }
    fmt.Printf("go net/http: status %d\n", resp.StatusCode)
}

use LWP::UserAgent;

# Default
my $ua = LWP::UserAgent->new(agent => 'wal-sh-test/perl-default');
my $resp = $ua->head('https://wal.sh/ouroboros/a');
my @r = $resp->redirects;
printf "perl LWP (default): %d redirects, final status %s\n",
    scalar(@r), $resp->status_line;

# With high limit
my $ua2 = LWP::UserAgent->new(agent => 'wal-sh-test/perl', max_redirect => 100);
my $resp2 = $ua2->head('https://wal.sh/ouroboros/a');
my @r2 = $resp2->redirects;
printf "perl LWP (max_redirect 100): %d redirects, final status %s\n",
    scalar(@r2), $resp2->status_line;

require 'net/http'
require 'uri'

url = 'https://wal.sh/ouroboros/a'
hops = 0
loop do
  uri = URI(url)
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  req = Net::HTTP::Head.new(uri)
  req['User-Agent'] = 'wal-sh-test/ruby'
  resp = http.request(req)
  break unless resp.is_a?(Net::HTTPRedirection) && hops < 100
  url = resp['location']
  hops += 1
end
puts "ruby net/http: #{hops} hops (manual, no built-in limit)"

require "http/client"

hops = 0
url = "https://wal.sh/ouroboros/a"
loop do
  uri = URI.parse(url)
  client = HTTP::Client.new(uri)
  resp = client.head(uri.request_target,
    headers: HTTP::Headers{"User-Agent" => "wal-sh-test/crystal"})
  break unless resp.status.redirection? && hops < 100
  loc = resp.headers["Location"]?
  break unless loc
  url = loc
  hops += 1
end
puts "crystal: #{hops} hops (manual, no built-in limit)"

(import '[java.net URL HttpURLConnection])

(defn count-redirects [url max-hops]
  (loop [u url hops 0]
    (if (>= hops max-hops)
      {:hops hops :status :limit-hit}
      (let [conn (doto (.openConnection (URL. u))
                   (.setInstanceFollowRedirects false)
                   (.setRequestMethod "HEAD")
                   (.setRequestProperty "User-Agent" "wal-sh-test/bb")
                   (.connect))
            code (.getResponseCode conn)
            loc  (.getHeaderField conn "Location")]
        (.disconnect conn)
        (if (and (<= 300 code 399) loc)
          (recur loc (inc hops))
          {:hops hops :status code})))))

(println (str "clojure manual: " (count-redirects "https://wal.sh/ouroboros/a" 100)))

#!/usr/bin/env escript
count(_, Max, Hops) when Hops >= Max ->
    io:format("erlang manual: ~p hops (limit hit)~n", [Hops]);
count(Url, Max, Hops) ->
    case httpc:request(head, {Url, [{"user-agent", "wal-sh-test/erlang"}]},
                       [{autoredirect, false}], []) of
        {ok, {{_, Code, _}, Headers, _}} when Code >= 300, Code < 400 ->
            case proplists:get_value("location", Headers) of
                undefined -> io:format("erlang: ~p hops, no location~n", [Hops]);
                Loc -> count(Loc, Max, Hops + 1)
            end;
        {ok, {{_, Code, _}, _, _}} ->
            io:format("erlang: ~p hops, status ~p~n", [Hops, Code]);
        {error, Reason} ->
            io:format("erlang: ~p hops, error ~p~n", [Hops, Reason])
    end.

main(_) ->
    inets:start(), ssl:start(),
    count("https://wal.sh/ouroboros/a", 100, 0).

Application.ensure_all_started(:inets)
Application.ensure_all_started(:ssl)

defmodule RedirectTest do
  def count(url, max, hops \\ 0)
  def count(_url, max, hops) when hops >= max do
    IO.puts("elixir manual: #{hops} hops (limit hit)")
  end
  def count(url, max, hops) do
    case :httpc.request(:head, {~c"#{url}", [{~c"user-agent", ~c"wal-sh-test/elixir"}]},
           [autoredirect: false], []) do
      {:ok, {{_, code, _}, headers, _}} when code >= 300 and code < 400 ->
        case :proplists.get_value(~c"location", headers) do
          :undefined -> IO.puts("elixir: #{hops} hops, no location")
          loc -> count(List.to_string(loc), max, hops + 1)
        end
      {:ok, {{_, code, _}, _, _}} ->
        IO.puts("elixir: #{hops} hops, status #{code}")
      {:error, reason} ->
        IO.puts("elixir: #{hops} hops, error #{inspect(reason)}")
    end
  end
end

RedirectTest.count("https://wal.sh/ouroboros/a", 100)

#lang racket/base
(require net/url)

(define (count-redirects url-str max-hops)
  (let loop ([u url-str] [hops 0])
    (cond
      [(>= hops max-hops)
       (printf "racket: ~a hops (limit hit)\n" hops)]
      [else
       (define p (head-impure-port (string->url u)
                   (list "User-Agent: wal-sh-test/racket")))
       (define line (read-line p))
       (define headers (port->string p))
       (close-input-port p)
       (define m (regexp-match #rx"HTTP/[0-9.]+ ([0-9]+)" line))
       (define code (if m (string->number (cadr m)) 0))
       (define loc-m (regexp-match #rx"(?i:location): ([^\r\n]+)" headers))
       (define loc (and loc-m (cadr loc-m)))
       (if (and (>= code 300) (< code 400) loc)
           (loop loc (+ hops 1))
           (printf "racket: ~a hops, status ~a\n" hops code))])))

(count-redirects "https://wal.sh/ouroboros/a" 100)

(use-modules (web client) (web response) (web uri))

(define (count-redirects url max-hops)
  (let loop ((u url) (hops 0))
    (if (>= hops max-hops)
        (format #t "guile3: ~a hops (limit hit)~%" hops)
        (catch 'gnutls-not-available
          (lambda ()
            (call-with-values
              (lambda () (http-head (string->uri u)
                          #:headers `((user-agent . "wal-sh-test/guile3"))))
              (lambda (resp body)
                (let ((code (response-code resp))
                      (loc (response-location resp)))
                  (if (and (>= code 300) (< code 400) loc)
                    (loop (uri->string loc) (1+ hops))
                    (format #t "guile3: ~a hops, status ~a~%" hops code))))))
          (lambda (key . args)
            (format #t "guile3: TLS error at hop ~a~%" hops))))))

(count-redirects "http://wal.sh/ouroboros/a" 100)

(use-modules (web client) (web response) (web uri))
(let loop ((u "http://wal.sh/ouroboros/a") (h 0))
  (if (>= h 100) (format #t "guile3: ~a hops (limit hit)~%" h)
    (catch #t
      (lambda () (call-with-values
        (lambda () (http-head (string->uri u)
                    #:headers `((user-agent . "wal-sh-test/guile3"))))
        (lambda (resp body)
          (let ((code (response-code resp))
                (loc (response-location resp)))
            (if (and (>= code 300) (< code 400) loc)
              (loop (uri->string loc) (1+ h))
              (format #t "guile3: ~a hops, status ~a~%" h code))))))
      (lambda (key . args) (format #t "guile3: error at hop ~a: ~a~%" h key)))))

(defn http-head [url]
  (def parsed (peg/match ~{:main (* "http://" (<- (to "/")) (<- (any 1)))} url))
  (def host (get parsed 0))
  (def path (get parsed 1))
  (def conn (net/connect host "80"))
  (net/write conn (string "HEAD " path " HTTP/1.0\r\nHost: " host
                          "\r\nUser-Agent: wal-sh-test/janet\r\nConnection: close\r\n\r\n"))
  (def resp (string (net/read conn 4096)))
  (net/close conn)
  (def status-match (peg/match ~(* "HTTP/" (some :d) "." (some :d) " " (<- (some :d))) resp))
  (def status (scan-number (get status-match 0)))
  (def loc-match (peg/match ~(* (thru "ocation: ") (<- (to "\r"))) resp))
  (def location (if loc-match (get loc-match 0) nil))
  {:status status :location location})

(var url "http://wal.sh/ouroboros/a")
(var hops 0)
(while (< hops 100)
  (def resp (http-head url))
  (if (and (>= (resp :status) 300) (< (resp :status) 400) (resp :location))
    (do (set url (resp :location)) (++ hops))
    (do (printf "janet: %d hops, status %d" hops (resp :status)) (break))))
(when (>= hops 100) (printf "janet: %d hops (limit hit)" hops))

using System.Net.Http;
var handler = new HttpClientHandler();
var client = new HttpClient(handler);
client.DefaultRequestHeaders.Add("User-Agent", "wal-sh-test/dotnet");
try {
    var resp = await client.SendAsync(
        new HttpRequestMessage(HttpMethod.Head, "http://wal.sh/ouroboros/a"));
    Console.WriteLine($"dotnet: status {(int)resp.StatusCode}");
} catch (HttpRequestException ex) {
    Console.WriteLine($"dotnet: {ex.GetType().Name}: {ex.Message}");
}

const std = @import("std");
const http = std.http;

pub fn main() !void {
    var client: http.Client = .{ .allocator = std.heap.page_allocator };
    defer client.deinit();

    const uri = try std.Uri.parse("http://wal.sh/ouroboros/a");
    var redirect_buf: [8192]u8 = undefined;
    var req = try client.request(.HEAD, uri, .{
        .headers = .{ .user_agent = .{ .override = "wal-sh-test/zig" } },
    });
    defer req.deinit();

    try req.sendBodiless();
    const resp = req.receiveHead(&redirect_buf) catch |err| {
        std.debug.print("zig: error {} (hit redirect limit of 3)\n", .{err});
        return;
    };

    std.debug.print("zig: status {d}\n", .{@intFromEnum(resp.head.status)});
}

grep 'wal-sh-test' logs/wal.sh/https/access.log \
  | awk -F'"' '{print $6}' | sort | uniq -c | sort -rn