Updated list command to handle errors

adsb/src/device.rs

@@ -18,23 +18,41 @@ pub struct RtlSdrDevice {
 
 impl RtlSdrDevice {
   /// List devices
-  pub fn list() -> Result<()> {
+  pub fn list() {
-    for device in DeviceList::new()?.iter() {
+    let device_list = match DeviceList::new() {
-      let device_desc = device.device_descriptor()?;
+      Ok(d) => d,
+      Err(err) => {
+        eprintln!("Unable to get device list: {:?}", err);
+        return;
+      }
+    };
+    for device in device_list.iter() {
+      match device.device_descriptor() {
+        Ok(device_desc) => {
+          println!(
+            "Bus: {:03}, Device: {:03} VID: 0x{:04X}, PID: 0x{:04X}",
+            device.bus_number(),
+            device.address(),
+            device_desc.vendor_id(),
+            device_desc.product_id()
+          );
 
-      println!(
+          match device.open() {
-        "Bus: {:03}, Device: {:03} VID: 0x{:04X}, PID: 0x{:04X}",
+            Ok(handle) => {
-        device.bus_number(),
+              println!("{}", device_info(&handle, &device_desc, "  ", true));
-        device.address(),
+            },
-        device_desc.vendor_id(),
+            Err(err) => {
-        device_desc.product_id()
+              eprintln!("  Unable to open device: {:?}", err);
-      );
+              continue;
-
+            }
-      let handle = device.open()?;
+          };
-      println!("{}", device_info(&handle, &device_desc, "  ", true)?);
+        }
+        Err(err) => {
+          eprintln!("Unable to get device descriptor: {:?}", err);
+          continue;
+        }
+      };
     }
-
-    Ok(())
   }
 
   /// Open the USB device and return a wrapper
@@ -67,10 +85,7 @@ impl RtlSdrDevice {
       transfer_type
     );
 
-    log::debug!(
+    log::debug!("{}", device_info(&self.handle, &self.device_desc, "", false));
-      "{}",
-      device_info(&self.handle, &self.device_desc, "", false)?
-    );
 
     // Read endpoint
     match Endpoint::find_readable(&self.device, &self.device_desc, transfer_type) {
@@ -87,8 +102,13 @@ fn device_info<T: UsbContext>(
   device_desc: &DeviceDescriptor,
   offset: &str,
   full: bool,
-) -> Result<String> {
+) -> String {
-  let languages = handle.read_languages(TIMEOUT)?;
+  let languages = match handle.read_languages(TIMEOUT) {
+    Ok(l) => l,
+    Err(err) => {
+      return format!("{} Unable to get languages: {:?}", offset, err);
+    },
+  };
   let descriptor_type = device_desc.descriptor_type();
   let mut output = String::new();
   if full {
@@ -96,9 +116,12 @@ fn device_info<T: UsbContext>(
   }
   if !languages.is_empty() {
     for language in languages {
-      let manufacturer = handle.read_manufacturer_string(language, device_desc, TIMEOUT)?;
+      let manufacturer = handle.read_manufacturer_string(language, device_desc, TIMEOUT)
-      let product = handle.read_product_string(language, device_desc, TIMEOUT)?;
+        .unwrap_or_else(|err| err.to_string());
-      let serial_number = handle.read_serial_number_string(language, device_desc, TIMEOUT)?;
+      let product = handle.read_product_string(language, device_desc, TIMEOUT)
+        .unwrap_or_else(|err| err.to_string());
+      let serial_number = handle.read_serial_number_string(language, device_desc, TIMEOUT)
+        .unwrap_or_else(|err| err.to_string());
       output.push_str(&format!(
         "{}{}Manufacturer: {}, Product: {}, Serial Number: {}",
         offset, offset, manufacturer, product, serial_number
@@ -121,13 +144,13 @@ fn device_info<T: UsbContext>(
         let protocol = device_desc.protocol_code();
         let max_packet_size = device_desc.max_packet_size();
         output.push_str(&format!(
-          "{}{}Class: {:#04x}, Subclass: {:#04x}, Protocol: {:#04x}, Max Packet Size: {}",
+          "{}{}Class: {:#04x}, Subclass: {:#04x}, Protocol: {:#04x}, Max Packet Size: {}\n",
           offset, offset, class, sub_class, protocol, max_packet_size
         ))
       }
     }
   }
-  Ok(output)
+  output
 }
 
 #[derive(Debug)]

adsb/src/main.rs

@@ -49,7 +49,8 @@ fn main() -> Result<()> {
   }
   // List devices
   else if args.list {
-    RtlSdrDevice::list()
+    RtlSdrDevice::list();
+    Ok(())
   }
   // Handle decode mode
   else if let Some(mut hex_string) = args.decode {