unexport: implement unexport* functionality

Also, fix up a few minor things with export (was not
respecing export flag previously).

Signed-off-by: Paul Osborne <[email protected]>

Author: posborne

src/commands/gpio_exportall.rs

@@ -11,7 +11,8 @@ pub fn main(config: &GpioConfig, opts: &GpioExportAllOptions) {
         None => config.get_symlink_root(),
     };
 
-    for pin in config.get_pins() {
+    // export all pins except those fork which export is set to false
+    for pin in config.get_pins().iter().filter(|p| p.export) {
         if let Err(e) = export::export(pin, Some(symlink_root)) {
             println!("Error occurred while exporting pin: {:?}", pin);
             println!("{}", e);

src/commands/gpio_read.rs

@@ -1,6 +1,6 @@
 // Copyright (C) 2016, Paul Osborne <[email protected]>
 
-use options::{GpioReadOptions};
+use options::GpioReadOptions;
 use config::GpioConfig;
 use std::process::exit;
 

src/commands/gpio_unexport.rs

@@ -0,0 +1,24 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioUnexportOptions;
+use config::GpioConfig;
+use std::process::exit;
+use export;
+
+pub fn main(config: &GpioConfig, opts: &GpioUnexportOptions) {
+    let pin_config = config.get_pin(&opts.pin[..]).unwrap_or_else(|| {
+        println!("Unable to find config entry for pin '{}'", opts.pin);
+        exit(1)
+    });
+
+    let symlink_root = match opts.symlink_root {
+        Some(ref slr) => &slr[..],
+        None => config.get_symlink_root(),
+    };
+
+    if let Err(e) = export::unexport(pin_config, Some(symlink_root)) {
+        println!("Error occurred while unexport pin {:?}", pin_config);
+        println!("{}", e);
+        exit(1);
+    }
+}

src/commands/gpio_unexportall.rs

@@ -0,0 +1,21 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioUnexportAllOptions;
+use config::GpioConfig;
+use std::process::exit;
+use export;
+
+pub fn main(config: &GpioConfig, opts: &GpioUnexportAllOptions) {
+    let symlink_root = match opts.symlink_root {
+        Some(ref slr) => &slr[..],
+        None => config.get_symlink_root(),
+    };
+
+    for pin in config.get_pins().iter().filter(|p| p.export) {
+        if let Err(e) = export::unexport(pin, Some(symlink_root)) {
+            println!("Error occurred while exporting pin: {:?}", pin);
+            println!("{}", e);
+            exit(1);
+        }
+    }
+}

src/commands/mod.rs

@@ -4,3 +4,5 @@ pub mod gpio_read;
 pub mod gpio_export;
 pub mod gpio_exportall;
 pub mod gpio_write;
+pub mod gpio_unexport;
+pub mod gpio_unexportall;

src/export.rs

@@ -7,6 +7,45 @@ use std::io::ErrorKind;
 use config::PinConfig;
 use sysfs_gpio;
 
+/// Unexport the pin specified in the provided config
+///
+/// Unexporting a config (in this context) involves a few different
+/// actions:
+///
+/// 1. For each GPIO name/alias, the corresponding symlink is remvoed from
+///    `/var/run/gpio/<name>` (or an alternate configured symlink_root).
+/// 2. The GPIO pin istself is unexported (vai /sys/class/gpio/unexport)
+///
+/// If the GPIO was already unexported, this function will continue
+/// without an error as the desired end state is achieved.
+pub fn unexport(pin_config: &PinConfig,
+                symlink_root: Option<&str>)
+                -> Result<(), sysfs_gpio::Error> {
+    if let Some(symroot) = symlink_root {
+        // create symlink for each name
+        for name in &pin_config.names {
+            let mut dst = path::PathBuf::from(symroot);
+            dst.push(name);
+            try!(match fs::remove_file(dst) {
+                Ok(_) => Ok(()),
+                Err(ref e) if e.kind() == ErrorKind::NotFound => Ok(()),
+                Err(e) => Err(e),
+            });
+        }
+    }
+
+    // unexport the pin itself.  On many boards, it turns out, some pins are
+    // exported by the kernel itself but we might still be assigning names.  In
+    // those cases we will get an error here.  We handle that rather than
+    // exposing the error up the chain. (EINVAL)
+    let pin = pin_config.get_pin();
+    match pin.unexport() {
+        Ok(_) => Ok(()),
+        Err(sysfs_gpio::Error::Io(ref e)) if e.kind() == ErrorKind::InvalidInput => Ok(()),
+        Err(e) => Err(e)
+    }
+}
+
 /// Export the pin specified in the provided config
 ///
 /// Exporting a pin (in this context) involves, a few different

src/main.rs

@@ -88,15 +88,23 @@ fn main() {
                     .arg(Arg::with_name("pin")
                          .help("The pin name (or number)")
                          .index(1)
-                         .required(true)))
+                         .required(true))
+                    .arg(Arg::with_name("symlink-root")
+                         .help("root directory for export symlinks")
+                         .takes_value(true)
+                         .short("r")
+                         .long("symlink-root")
+                         .required(false)))
 
         // gpio unexport-all
         .subcommand(SubCommand::with_name("unexport-all")
                     .about("Unexport all configured, exported GPIOs")
-                    .arg(Arg::with_name("pin")
-                         .help("The pin name (or number)")
-                         .index(1)
-                         .required(true)))
+                    .arg(Arg::with_name("symlink-root")
+                         .help("root directory for export symlinks")
+                         .takes_value(true)
+                         .short("r")
+                         .long("symlink-root")
+                         .required(false)))
 
         // gpio status
         .subcommand(SubCommand::with_name("status")
@@ -169,8 +177,21 @@ fn main() {
             };
             gpio_exportall::main(&cfg, &exportall_options);
         }
-        ("unexport", Some(_)) => {}
-        ("unexport-all", Some(_)) => {}
+        ("unexport", Some(m)) => {
+            let unexport_options = GpioUnexportOptions {
+                gpio_opts: gpio_options,
+                pin: String::from(m.value_of("pin").unwrap()),
+                symlink_root: m.value_of("symlink-root").map(|slr| String::from(slr)),
+            };
+            gpio_unexport::main(&cfg, &unexport_options);
+        }
+        ("unexport-all", Some(m)) => {
+            let unexportall_options = GpioUnexportAllOptions {
+                gpio_opts: gpio_options,
+                symlink_root: m.value_of("symlink-root").map(|slr| String::from(slr)),
+            };
+            gpio_unexportall::main(&cfg, &unexportall_options);
+        }
         ("status", Some(_)) => {}
         _ => {}
     }

src/options.rs

@@ -40,12 +40,14 @@ pub struct GpioExportAllOptions {
 #[derive(Debug)]
 pub struct GpioUnexportOptions {
     pub gpio_opts: GpioOptions,
+    pub symlink_root: Option<String>,
     pub pin: String,
 }
 
 #[derive(Debug)]
 pub struct GpioUnexportAllOptions {
     pub gpio_opts: GpioOptions,
+    pub symlink_root: Option<String>,
 }
 
 #[derive(Debug)]