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)

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