http-downstream: Who's Actually Asking

interface http-downstream {
  use types.{error, ip-address};
  use http-req.{
    request, client-cert-verify-result, error-with-detail, cache-override, pending-request,
    request-with-body,
  };

  ...

  /// Returns the client request's header names exactly as they were originally received.
  ///
  /// This includes both the original header name characters' cases, as well as the original order
  /// of the received headers.
  ///
  /// The first `cursor` names are skipped. The remaining names are encoded successively with
  /// a NUL byte after each into a list of bytes at most `max-len` long. If any of the remaining
  /// names don't fit, the returned `option<u32>` is the index of the first name that didn't fit,
  /// or `none` if all the remaining names fit. If `max-len` is too small to fit any name,
  /// an `error.buffer-len` error is returned, providing a recommended buffer size.
  downstream-original-header-names: func(
    ds-request: borrow<request>,
    max-len: u64,
    cursor: u32,
  ) -> result<tuple<string, option<u32>>, error>;

  /// Returns the number of headers in the client request as originally received.
  downstream-original-header-count: func(
    ds-request: borrow<request>
  ) -> result<u32, error>;

  /// Returns the IP address of the client making the HTTP request, if known.
  downstream-client-ip-addr: func(
    ds-request: borrow<request>
  ) -> option<ip-address>;

  /// Returns the IP address on which this server received the HTTP request, if known.
  downstream-server-ip-addr: func(
    ds-request: borrow<request>
  ) -> option<ip-address>;

  /// Gets the HTTP/2 fingerprint of client request if available.
  downstream-client-h2-fingerprint: func(
    ds-request: borrow<request>,
    max-len: u64
  ) -> result<string, error>;

  /// Gets the id of the current request if available.
  downstream-client-request-id: func(
    ds-request: borrow<request>,
    max-len: u64
  ) -> result<string, error>;

  /// Gets the fingerprint of client request headers if available.
  downstream-client-oh-fingerprint: func(
    ds-request: borrow<request>,
    max-len: u64
  ) -> result<string, error>;

  /// Returns whether the request was tagged as contributing to a DDoS attack.
  downstream-client-ddos-detected: func(
    ds-request: borrow<request>
  ) -> result<bool, error>;

  ...

  /// Gets the compliance region that the client IP address is in.
  downstream-compliance-region: func(
    ds-request: borrow<request>,
    max-len: u64
  ) -> result<option<string>, error>;

  /// Returns whether or not the original client request arrived with a
  /// Fastly-Key belonging to a user with the rights to purge content on this
  /// service.
  fastly-key-is-valid: func(
    ds-request: borrow<request>,
  ) -> result<bool, error>;

  ...

  /// Returns the number of times we have previously visited this service
  /// as part of a service chain. This data is only reliable as long as the
  /// message stays within Fastly infrastructure; if it leaves and returns,
  /// it can be modified or spoofed.
  downstream-visits-this-service: func() -> result<u64, error>;

  /// Returns the number of times we have previously visited this POP
  /// as part of a service chain. This data is only reliable as long as the
  /// message stays within Fastly infrastructure; if it leaves and returns,
  /// it can be modified or spoofed.
  downstream-visits-this-pop: func() -> result<u64, error>;
}

call_growable, generic buffer-retry helper (12 lines)
fn call_growable<T>(
    mut f: impl FnMut(u64) -> Result<T, http_downstream::Error>,
) -> Result<T, http_downstream::Error> {
    let mut max_len: u64 = 256;
    loop {
        match f(max_len) {
            Ok(v) => return Ok(v),
            Err(http_downstream::Error::BufferLen(needed)) => max_len = needed,
            Err(e) => return Err(e),
        }
    }
}

header_names, cursor pagination, same shape as get_header_values (23 lines)
fn header_names(request: &http_incoming::Request) -> Result<Vec<String>, http_downstream::Error> {
    let mut names = Vec::new();
    let mut cursor: u32 = 0;
    let mut max_len: u64 = 256;

    loop {
        match http_downstream::downstream_original_header_names(request, max_len, cursor) {
            Ok((text, more)) => {
                names.extend(
                    text.split('\0')
                        .filter(|chunk| !chunk.is_empty())
                        .map(|chunk| chunk.to_string()),
                );
                match more {
                    Some(next_cursor) => cursor = next_cursor,
                    None => return Ok(names),
                }
            }
            Err(http_downstream::Error::BufferLen(needed)) => max_len = needed,
            Err(e) => return Err(e),
        }
    }
}

let names = header_names(&request).map_err(|_| ())?;
let count = http_downstream::downstream_original_header_count(&request).map_err(|_| ())?;

let client_ip = format_ip(http_downstream::downstream_client_ip_addr(&request));
let server_ip = format_ip(http_downstream::downstream_server_ip_addr(&request));

let h2_fingerprint = call_growable(|max_len| {
    http_downstream::downstream_client_h2_fingerprint(&request, max_len)
});
let request_id = call_growable(|max_len| {
    http_downstream::downstream_client_request_id(&request, max_len)
});
let oh_fingerprint = call_growable(|max_len| {
    http_downstream::downstream_client_oh_fingerprint(&request, max_len)
});
let ddos_detected = http_downstream::downstream_client_ddos_detected(&request);
let compliance_region = call_growable(|max_len| {
    http_downstream::downstream_compliance_region(&request, max_len)
});
let fastly_key_valid = http_downstream::fastly_key_is_valid(&request);
let visits_service = http_downstream::downstream_visits_this_service();
let visits_pop = http_downstream::downstream_visits_this_pop();

downstream-original-header-count: 3
downstream-original-header-names: ["host", "user-agent", "accept"]
downstream-client-ip-addr:  127.0.0.1
downstream-server-ip-addr:  127.0.0.1
downstream-client-h2-fingerprint: Err(Error::GenericError)
downstream-client-request-id:     Ok("00000000000000000000000000000000")
downstream-client-oh-fingerprint: Err(Error::GenericError)
downstream-client-ddos-detected:  Ok(false)
downstream-compliance-region:     Ok(Some("none"))
fastly-key-is-valid:        Ok(false)
downstream-visits-this-service: Err(Error::Unsupported)
downstream-visits-this-pop:     Err(Error::Unsupported)