Function handle_prpc_impl

ra-rpc/src/rocket_helper.rs:504–580

(
    args: PrpcHandler<'_, '_, S>,
)

}

pub async fn handle_prpc_impl<S, Call: RpcCall<S>>(
    args: PrpcHandler<'_, '_, S>,
) -> Result<RpcResponse> {
    let PrpcHandler {
        state,
        request,
        method,
        method_trim_prefix,
        data,
    } = args;
    let method = method.trim_start_matches(method_trim_prefix.unwrap_or_default());
    let info = request
        .certificate
        .as_ref()
        .map(|cert| -> Result<_> {
            let app_id = RocketCertificate(cert).get_app_id()?;
            let app_info = RocketCertificate(cert).get_app_info()?;
            Ok((app_id, app_info))
        })
        .transpose()?;
    let (remote_app_id, remote_app_info) = match info {
        Some((app_id, app_info)) => (app_id, app_info),
        None => (None, None),
    };
    let attestation = request
        .certificate
        .as_ref()
        .map(|cert| ra_tls::attestation::from_der(cert.as_bytes()))
        .transpose()?
        .flatten();
    let attestation = match (request.quote_verifier, attestation) {
        (Some(quote_verifier), Some(attestation)) => {
            let pubkey = request
                .certificate
                .context("certificate is missing")?
                .public_key()
                .raw
                .to_vec();
            let verified = attestation
                .into_v1()
                .verify_with_ra_pubkey(&pubkey, quote_verifier.pccs_url.as_deref())
                .await
                .context("invalid quote")?;
            Some(verified)
        }
        _ => None,
    };
    let payload = match data {
        Some(data) => {
            let limit = limit_for_method(method, request.limits);
            read_data(data, limit)
                .await
                .context("failed to read data")?
        }
        None => request
            .origin
            .query()
            .map_or(vec![], |q| q.as_bytes().to_vec()),