chore: update ureq (#1278)

Author: ok-nick

Cargo.lock

@@ -204,7 +204,8 @@ tempfile = { version = "3.15", features = ["nightly"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 openssl = { version = "0.10.72", features = ["vendored"], optional = true }
-ureq = "2.4.0"
+ureq = "3.0.12"
+http = "1.3.1"
 url = "2.5.3"
 
 [target.'cfg(any(target_os = "wasi", not(target_arch = "wasm32")))'.dependencies]

sdk/Cargo.toml

@@ -37,7 +37,7 @@ fn main() -> Result<()> {
                 println!("Fetching remote manifest from {url}");
                 let mut c2pa_data = Vec::new();
                 let resp = ureq::get(&url).call()?;
-                resp.into_reader().read_to_end(&mut c2pa_data)?;
+                resp.into_body().into_reader().read_to_end(&mut c2pa_data)?;
                 Reader::from_manifest_data_and_stream(&c2pa_data, &format, &mut file)
             }
             Err(Error::JumbfNotFound) => {

sdk/examples/v2show.rs

@@ -101,21 +101,21 @@ pub(crate) fn fetch_ocsp_response(certs: &[Vec<u8>]) -> Option<Vec<u8>> {
             // fetch OCSP response
             let request = ureq::get(req_url.as_str());
             let response = if let Some(host) = url.host() {
-                request.set("Host", &host.to_string()).call().ok()? // for responders that don't support http 1.0
+                request.header("Host", &host.to_string()).call().ok()? // for responders that don't support http 1.0
             } else {
                 request.call().ok()?
             };
 
             if response.status() == 200 {
-                let len = response
-                    .header("Content-Length")
-                    .and_then(|s| s.parse::<usize>().ok())
+                let body = response.into_body();
+                let len = body
+                    .content_length()
+                    .and_then(|s| s.try_into().ok())
                     .unwrap_or(10000);
 
                 let mut ocsp_rsp: Vec<u8> = Vec::with_capacity(len);
 
-                response
-                    .into_reader()
+                body.into_reader()
                     .take(1000000)
                     .read_to_end(&mut ocsp_rsp)
                     .ok()?;

sdk/src/crypto/ocsp/fetch.rs

@@ -53,8 +53,8 @@ pub enum TimeStampError {
     NonceMismatch,
 
     /// The time stamp service responded with an error condition.
-    #[error("service responded with an HTTP error (status = {0}, content-type = {1})")]
-    HttpErrorResponse(u16, String),
+    #[error("service responded with an HTTP error (status = {0}, content-type = {1:?})")]
+    HttpErrorResponse(u16, Option<String>),
 
     /// Unable to complete the HTTPS time stamp request.
     ///

sdk/src/crypto/time_stamp/error.rs

@@ -13,6 +13,7 @@
 
 use async_generic::async_generic;
 use bcder::{decode::Constructed, encode::Values};
+use http::header;
 
 use crate::{
     crypto::{
@@ -85,24 +86,27 @@ fn time_stamp_request_http(
 
     if let Some(headers) = headers {
         for (ref name, ref value) in headers {
-            req = req.set(name.as_str(), value.as_str());
+            req = req.header(name.as_str(), value.as_str());
         }
     }
 
     let response = req
-        .set("Content-Type", HTTP_CONTENT_TYPE_REQUEST)
-        .send_bytes(&body)?;
-
-    if response.status() == 200 && response.content_type() == HTTP_CONTENT_TYPE_RESPONSE {
-        let len = response
-            .header("Content-Length")
-            .and_then(|s| s.parse::<usize>().ok())
+        .header(header::CONTENT_TYPE, HTTP_CONTENT_TYPE_REQUEST)
+        .send(&body)?;
+
+    let content_type = response
+        .headers()
+        .get(header::CONTENT_TYPE)
+        .and_then(|header| header.to_str().ok());
+    if response.status() == 200 && content_type == Some(HTTP_CONTENT_TYPE_RESPONSE) {
+        let body = response.into_body();
+        let len = body
+            .content_length()
+            .and_then(|content_length| content_length.try_into().ok())
             .unwrap_or(20000);
-
         let mut response_bytes: Vec<u8> = Vec::with_capacity(len);
 
-        response
-            .into_reader()
+        body.into_reader()
             .take(1000000)
             .read_to_end(&mut response_bytes)?;
 
@@ -125,8 +129,8 @@ fn time_stamp_request_http(
         Ok(response_bytes)
     } else {
         Err(TimeStampError::HttpErrorResponse(
-            response.status(),
-            response.content_type().to_string(),
+            response.status().as_u16(),
+            content_type.map(|content_type| content_type.to_owned()),
         ))
     }
 }

sdk/src/crypto/time_stamp/http_request.rs

@@ -324,7 +324,9 @@ impl Settings {
         let toml = ureq::get(url)
             .call()
             .map_err(|_| Error::FailedToFetchSettings)?
-            .into_string()?;
+            .into_body()
+            .read_to_string()
+            .map_err(|_| Error::FailedToFetchSettings)?;
         Settings::from_toml(&toml)
     }
 

sdk/src/settings/mod.rs

@@ -123,10 +123,11 @@ impl Signer for RemoteSigner {
         use std::io::Read;
 
         let response = ureq::post(&self.url)
-            .send_bytes(data)
+            .send(data)
             .map_err(|_| Error::FailedToRemoteSign)?;
         let mut bytes: Vec<u8> = Vec::with_capacity(self.reserve_size);
         response
+            .into_body()
             .into_reader()
             .take(self.reserve_size as u64)
             .read_to_end(&mut bytes)?;

sdk/src/settings/signer.rs

@@ -3711,26 +3711,25 @@ impl Store {
     #[cfg(all(feature = "fetch_remote_manifests", not(target_os = "wasi")))]
     fn fetch_remote_manifest(url: &str) -> Result<Vec<u8>> {
         use conv::ValueFrom;
-        use ureq::Error as uError;
 
         //const MANIFEST_CONTENT_TYPE: &str = "application/x-c2pa-manifest-store"; // todo verify once these are served
         const DEFAULT_MANIFEST_RESPONSE_SIZE: usize = 10 * 1024 * 1024; // 10 MB
 
         match ureq::get(url).call() {
             Ok(response) => {
                 if response.status() == 200 {
-                    let len = response
-                        .header("Content-Length")
-                        .and_then(|s| s.parse::<usize>().ok())
+                    let body = response.into_body();
+                    let len = body
+                        .content_length()
+                        .and_then(|content_length| content_length.try_into().ok())
                         .unwrap_or(DEFAULT_MANIFEST_RESPONSE_SIZE); // todo figure out good max to accept
 
                     let mut response_bytes: Vec<u8> = Vec::with_capacity(len);
 
                     let len64 = u64::value_from(len)
                         .map_err(|_err| Error::BadParam("value out of range".to_string()))?;
 
-                    response
-                        .into_reader()
+                    body.into_reader()
                         .take(len64)
                         .read_to_end(&mut response_bytes)
                         .map_err(|_err| {
@@ -3741,17 +3740,12 @@ impl Store {
                 } else {
                     Err(Error::RemoteManifestFetch(format!(
                         "fetch failed: code: {}, status: {}",
-                        response.status(),
-                        response.status_text()
+                        response.status().as_u16(),
+                        response.status().as_str()
                     )))
                 }
             }
-            Err(uError::Status(code, resp)) => Err(Error::RemoteManifestFetch(format!(
-                "code: {}, response: {}",
-                code,
-                resp.status_text()
-            ))),
-            Err(uError::Transport(_)) => Err(Error::RemoteManifestFetch(url.to_string())),
+            Err(err) => Err(Error::RemoteManifestFetch(err.to_string())),
         }
     }