     end
   end
 
+  defp do_maybe_handle_route(%Message{start_line: %RequestLine{}} = request) do
+    if request.headers |> Map.has_key?(:route) do
+      {_, target_uri, _} = hd(request.headers.route)
+      case URI.decode_parameters(target_uri.parameters) do
+        %{"lr" => _} ->
+          request  # no change
+        _no_lr ->
+          # strict-routing requirements
+          request_uri = request.start_line.request_uri
+          request =
+            request
+            |> Message.put_header_back(:route, {"", request_uri, %{}})
+            |> Message.delete_header_front(:route)
+
+          %{request | start_line:
+            %{request.start_line | request_uri: target_uri}}
+      end
+    else
+      request
+    end
+  end
+
   defp do_add_hash_branch(message) do
     # When the request is forwarded statelessly, like in the case of ACKs, the
     # branch has to be the same in the case of retransmissions. This way, a

  @spec forward_response(Message.response) :: on_response_sent
  def forward_response(%Message{start_line: %StatusLine{}} = response) do
    response
    |> remove_topmost_via()
    |> fallback_to_transport(&Transactions.send_response/1)
  end

  defp remove_topmost_via(message) do
    message =
      message |> Message.update_header(:via, [],
          fn [_ | t] -> t end)

    if message.headers.via == [] do
      raise ArgumentError, "Via cannot be empty, wrong message forward"
    end

    message
  end

  defp fallback_to_transport(message, fun) do

  def forward_response(%Message{start_line: %StatusLine{}} = response,
                       %Transactions.Server.Key{} = server_key) do
    response
    |> fallback_to_transport(&Transactions.send_response(&1, server_key))
  end
end
