improved error handling:

provides both machine-readable error classification and human-readable detailed messages

  1. Error Kind Constants (in types.rs)

  Added 11 error type constants that map to LabVIEW enums:
  - ERROR_KIND_NONE through ERROR_KIND_UNKNOWN

  2. Enhanced Response Structure (in types.rs)

  Added three new fields to track error details:
  - error_kind: The type of error (timeout, connection, etc.)
  - error_url: The URL associated with the error
  - error_source: The root cause from the error chain

  3. Error Analysis Function (in async_support.rs)

  Created analyze_reqwest_error() that:
  - Classifies errors using reqwest's is_*() methods
  - Extracts the URL if available
  - Gets the root cause via source()
  - Builds a detailed error message with the full error chain

  4. New FFI Functions (in ffi/request.rs)

  - request_get_error_kind() - Returns the error type constant
  - request_get_error_message() - Returns the detailed error message
  - request_get_error_url() - Returns the URL if available
  - request_get_error_source() - Returns the root cause
  - request_response_has_error() - Checks if there's any error

  5. Exports Updated (in lib.rs)

  All new functions are exported for use by LabVIEW

  Now when you get a timeout error, you'll be able to:
  1. Call request_get_error_kind() and get ERROR_KIND_TIMEOUT (value 1)
  2. Call request_get_error_message() to get a detailed message including the root cause
  3. Call request_get_error_url() to see which URL failed
  4. Call request_get_error_source() to get just the underlying error cause

Author: jimkring

src/async_support.rs

@@ -1,12 +1,49 @@
-use crate::types::{RequestProgress, RequestStatus, Response};
+use crate::types::{RequestProgress, RequestStatus, Response, ERROR_KIND_NONE, ERROR_KIND_TIMEOUT, ERROR_KIND_CONNECTION, ERROR_KIND_REDIRECT, ERROR_KIND_INVALID_STATUS, ERROR_KIND_BODY, ERROR_KIND_DECODE, ERROR_KIND_BUILDER, ERROR_KIND_REQUEST, ERROR_KIND_FILE_SYSTEM, ERROR_KIND_UNKNOWN};
 use reqwest::Response as ReqwestResponse;
 use std::{
+    error::Error as StdError,
     fs::File,
     future::Future,
     io::Write,
     sync::{Arc, RwLock},
 };
 
+fn analyze_reqwest_error(e: &reqwest::Error) -> (u8, String, Option<String>, Option<String>) {
+    let error_kind = if e.is_timeout() {
+        ERROR_KIND_TIMEOUT
+    } else if e.is_connect() {
+        ERROR_KIND_CONNECTION
+    } else if e.is_redirect() {
+        ERROR_KIND_REDIRECT
+    } else if e.is_status() {
+        ERROR_KIND_INVALID_STATUS
+    } else if e.is_body() {
+        ERROR_KIND_BODY
+    } else if e.is_decode() {
+        ERROR_KIND_DECODE
+    } else if e.is_builder() {
+        ERROR_KIND_BUILDER
+    } else if e.is_request() {
+        ERROR_KIND_REQUEST
+    } else {
+        ERROR_KIND_UNKNOWN
+    };
+
+    let main_message = e.to_string();
+    
+    let url = e.url().map(|u| u.to_string());
+    
+    let source = e.source().map(|s| s.to_string());
+    
+    let detailed_message = if let Some(ref src) = source {
+        format!("{}: {}", main_message, src)
+    } else {
+        main_message
+    };
+
+    (error_kind, detailed_message, url, source)
+}
+
 // Process a request and handle the response stream within an async context
 pub async fn process_request(
     request_future: impl Future<Output = reqwest::Result<ReqwestResponse>>,
@@ -56,6 +93,9 @@ pub async fn process_request(
                                             version,
                                             headers,
                                             body: Err(format!("File write error: {e}")),
+                                            error_kind: ERROR_KIND_FILE_SYSTEM,
+                                            error_url: None,
+                                            error_source: Some(e.to_string()),
                                         });
                                         return;
                                     }
@@ -74,6 +114,9 @@ pub async fn process_request(
                                         version,
                                         headers,
                                         body: Err(format!("Network error: {e}")),
+                                        error_kind: ERROR_KIND_CONNECTION,
+                                        error_url: None,
+                                        error_source: Some(e.to_string()),
                                     });
                                     return;
                                 }
@@ -88,6 +131,9 @@ pub async fn process_request(
                             version,
                             headers,
                             body: Ok(Vec::new()), // Empty body since it was streamed to file
+                            error_kind: ERROR_KIND_NONE,
+                            error_url: None,
+                            error_source: None,
                         });
                     }
                     Err(e) => {
@@ -99,6 +145,9 @@ pub async fn process_request(
                             version,
                             headers,
                             body: Err(format!("File open error: {e}")),
+                            error_kind: ERROR_KIND_FILE_SYSTEM,
+                            error_url: None,
+                            error_source: Some(e.to_string()),
                         });
                     }
                 }
@@ -119,6 +168,9 @@ pub async fn process_request(
                             version,
                             headers,
                             body: Ok(bytes_vec),
+                            error_kind: ERROR_KIND_NONE,
+                            error_url: None,
+                            error_source: None,
                         });
                     }
                     Err(e) => {
@@ -130,20 +182,28 @@ pub async fn process_request(
                             version,
                             headers,
                             body: Err(format!("Body read error: {e}")),
+                            error_kind: ERROR_KIND_BODY,
+                            error_url: None,
+                            error_source: Some(e.to_string()),
                         });
                     }
                 }
             }
         }
         Err(e) => {
             // Request error (connection failed, etc.)
+            let (error_kind, error_message, error_url, error_source) = analyze_reqwest_error(&e);
+            
             let mut progress = progress_info.write().unwrap();
             progress.status = RequestStatus::Error;
             progress.final_response = Some(Response {
-                status: reqwest::StatusCode::BAD_REQUEST, // Default status code for errors
+                status: e.status().unwrap_or(reqwest::StatusCode::BAD_REQUEST),
                 version: reqwest::Version::HTTP_11,       // Default to HTTP/1.1 for errors
                 headers: reqwest::header::HeaderMap::new(),
-                body: Err(format!("Request error: {e}")),
+                body: Err(error_message),
+                error_kind,
+                error_url,
+                error_source,
             });
         }
     }

src/ffi/request.rs

@@ -296,3 +296,123 @@ pub extern "C" fn request_read_response_version(
     unsafe { *num_bytes = 0 };
     ptr::null_mut() // Return null if request not found or no response yet
 }
+
+/// Get the error kind from a response
+#[unsafe(no_mangle)]
+pub extern "C" fn request_get_error_kind(request_id: RequestId) -> u8 {
+    let tracker = REQUEST_TRACKER.lock().unwrap();
+
+    if let Some(progress_info) = tracker.get(&request_id) {
+        let progress = progress_info.read().unwrap();
+        if let Some(ref response) = progress.final_response {
+            return response.error_kind;
+        }
+    }
+
+    crate::types::ERROR_KIND_NONE
+}
+
+/// Get the error message with detailed information
+#[unsafe(no_mangle)]
+pub extern "C" fn request_get_error_message(
+    request_id: RequestId,
+    buffer: *mut c_char,
+    buffer_len: usize,
+) -> usize {
+    if buffer.is_null() || buffer_len == 0 {
+        return 0;
+    }
+
+    let tracker = REQUEST_TRACKER.lock().unwrap();
+
+    if let Some(progress_info) = tracker.get(&request_id) {
+        let progress = progress_info.read().unwrap();
+        if let Some(ref response) = progress.final_response {
+            if let Err(ref error_msg) = response.body {
+                let msg_len = error_msg.len().min(buffer_len - 1);
+                unsafe {
+                    std::ptr::copy_nonoverlapping(error_msg.as_ptr(), buffer as *mut u8, msg_len);
+                    *buffer.add(msg_len) = 0;
+                }
+                return msg_len;
+            }
+        }
+    }
+
+    0
+}
+
+/// Get the error URL if available
+#[unsafe(no_mangle)]
+pub extern "C" fn request_get_error_url(
+    request_id: RequestId,
+    buffer: *mut c_char,
+    buffer_len: usize,
+) -> usize {
+    if buffer.is_null() || buffer_len == 0 {
+        return 0;
+    }
+
+    let tracker = REQUEST_TRACKER.lock().unwrap();
+
+    if let Some(progress_info) = tracker.get(&request_id) {
+        let progress = progress_info.read().unwrap();
+        if let Some(ref response) = progress.final_response {
+            if let Some(ref url) = response.error_url {
+                let url_len = url.len().min(buffer_len - 1);
+                unsafe {
+                    std::ptr::copy_nonoverlapping(url.as_ptr(), buffer as *mut u8, url_len);
+                    *buffer.add(url_len) = 0;
+                }
+                return url_len;
+            }
+        }
+    }
+
+    0
+}
+
+/// Get the root cause error message
+#[unsafe(no_mangle)]
+pub extern "C" fn request_get_error_source(
+    request_id: RequestId,
+    buffer: *mut c_char,
+    buffer_len: usize,
+) -> usize {
+    if buffer.is_null() || buffer_len == 0 {
+        return 0;
+    }
+
+    let tracker = REQUEST_TRACKER.lock().unwrap();
+
+    if let Some(progress_info) = tracker.get(&request_id) {
+        let progress = progress_info.read().unwrap();
+        if let Some(ref response) = progress.final_response {
+            if let Some(ref source) = response.error_source {
+                let src_len = source.len().min(buffer_len - 1);
+                unsafe {
+                    std::ptr::copy_nonoverlapping(source.as_ptr(), buffer as *mut u8, src_len);
+                    *buffer.add(src_len) = 0;
+                }
+                return src_len;
+            }
+        }
+    }
+
+    0
+}
+
+/// Check if response has an error
+#[unsafe(no_mangle)]
+pub extern "C" fn request_response_has_error(request_id: RequestId) -> bool {
+    let tracker = REQUEST_TRACKER.lock().unwrap();
+
+    if let Some(progress_info) = tracker.get(&request_id) {
+        let progress = progress_info.read().unwrap();
+        if let Some(ref response) = progress.final_response {
+            return response.body.is_err() || response.error_kind != crate::types::ERROR_KIND_NONE;
+        }
+    }
+
+    false
+}

src/lib.rs

@@ -28,10 +28,12 @@ pub use ffi::multipart::{
     multipart_form_create, multipart_form_destroy, multipart_form_read_error_message,
 };
 pub use ffi::request::{
-    request_cancel, request_destroy, request_has_transport_error, request_is_complete,
-    request_read_progress, request_read_received_bytes, request_read_response_body,
-    request_read_response_headers, request_read_response_status, request_read_response_version,
-    request_read_total_bytes, request_read_transport_error,
+    request_cancel, request_destroy, request_get_error_kind, request_get_error_message,
+    request_get_error_source, request_get_error_url, request_has_transport_error,
+    request_is_complete, request_read_progress, request_read_received_bytes,
+    request_read_response_body, request_read_response_headers, request_read_response_status,
+    request_read_response_version, request_read_total_bytes, request_read_transport_error,
+    request_response_has_error,
 };
 pub use ffi::request_builder::{
     request_builder_basic_auth, request_builder_bearer_auth, request_builder_body,

src/types.rs

@@ -71,6 +71,9 @@ pub struct Response {
     pub version: Version,
     pub headers: HeaderMap,
     pub body: Result<Vec<u8>, String>,
+    pub error_kind: u8,
+    pub error_url: Option<String>,
+    pub error_source: Option<String>,
 }
 
 /// HTTP method constants
@@ -93,3 +96,16 @@ pub struct MultipartFormWrapper {
     pub form: Option<reqwest::multipart::Form>,
     pub error_message: Option<String>,
 }
+
+/// Error kind constants for FFI
+pub const ERROR_KIND_NONE: u8 = 0;
+pub const ERROR_KIND_TIMEOUT: u8 = 1;
+pub const ERROR_KIND_CONNECTION: u8 = 2;
+pub const ERROR_KIND_REDIRECT: u8 = 3;
+pub const ERROR_KIND_INVALID_STATUS: u8 = 4;
+pub const ERROR_KIND_BODY: u8 = 5;
+pub const ERROR_KIND_DECODE: u8 = 6;
+pub const ERROR_KIND_BUILDER: u8 = 7;
+pub const ERROR_KIND_REQUEST: u8 = 8;
+pub const ERROR_KIND_FILE_SYSTEM: u8 = 9;
+pub const ERROR_KIND_UNKNOWN: u8 = 10;