Use separate smb shares for each partition (fixes #42)

ALSchwalm · ALSchwalm · commit a852ddf09236 · 2018-10-14T17:09:11.000-05:00
diff --git a/pISO/src/action.rs b/pISO/src/action.rs
@@ -38,5 +38,8 @@ pub enum Action {
     FlipDisplay,
 
     OpenVersion,
-    CloseVersion
+    CloseVersion,
+
+    SmbSharePartition(String),
+    SmbRemoveShare(String),
 }
diff --git a/pISO/src/options.rs b/pISO/src/options.rs
@@ -19,7 +19,7 @@ pub struct Options {
     removable: buttons::vdrivelist::DriveList,
     delete: buttons::vdrivelist::DriveList,
     snapshot: buttons::vdrivelist::DriveList,
-    version: version::VersionMenu
+    version: version::VersionMenu,
 }
 
 impl Options {
@@ -79,7 +79,7 @@ impl Options {
             removable: removable,
             delete: delete,
             snapshot: snapshot,
-            version: version
+            version: version,
         })
     }
 }
@@ -120,7 +120,7 @@ impl Widget for Options {
                 &mut self.removable as &mut Widget,
                 &mut self.snapshot as &mut Widget,
                 &mut self.delete as &mut Widget,
-                &mut self.version as &mut Widget
+                &mut self.version as &mut Widget,
             ]
         } else {
             vec![]
@@ -134,7 +134,7 @@ impl Widget for Options {
                 &self.removable as &Widget,
                 &self.snapshot as &Widget,
                 &self.delete as &Widget,
-                &self.version as &Widget
+                &self.version as &Widget,
             ]
         } else {
             vec![]
diff --git a/pISO/src/piso.rs b/pISO/src/piso.rs
@@ -107,18 +107,45 @@ impl PIso {
         Ok(drives)
     }
 
-    fn add_drive(
-        &mut self,
-        disp: &mut DisplayManager,
+    fn add_drive<'a, 'b>(
+        &'a mut self,
+        disp: &'b mut DisplayManager,
         volume: lvm::LogicalVolume,
-    ) -> Result<&vdrive::VirtualDrive> {
-        let vdrive = vdrive::VirtualDrive::new(disp, self.usb.clone(), volume, &self.config)?;
+    ) -> Result<&'a mut vdrive::VirtualDrive> {
+        let mut vdrive = vdrive::VirtualDrive::new(disp, self.usb.clone(), volume, &self.config)?;
+        vdrive.mount_internal(disp)?;
         self.drives.push(vdrive);
 
         Ok(self.drives
-            .last()
+            .last_mut()
             .expect("vdrive was somehow empty after push"))
     }
+
+    fn share_drive(drive: &mut vdrive::VirtualDrive, remove: bool) -> Result<Vec<action::Action>> {
+        match drive.state {
+            vdrive::MountState::Unmounted | vdrive::MountState::External(_) => {
+                if remove {
+                    Ok(vec![])
+                } else {
+                    Err("Cannot share drive when not mounted internal".into())
+                }
+            }
+            vdrive::MountState::Internal(ref info) => Ok(info.part_mount_paths
+                .iter()
+                .map(|path| {
+                    let name = path.file_name()
+                        .expect("Partition has no name")
+                        .to_string_lossy()
+                        .into_owned();
+                    if remove {
+                        action::Action::SmbRemoveShare(name)
+                    } else {
+                        action::Action::SmbSharePartition(name)
+                    }
+                })
+                .collect()),
+        }
+    }
 }
 
 impl render::Render for PIso {
@@ -145,23 +172,27 @@ impl input::Input for PIso {
                 Ok((true, vec![]))
             }
             action::Action::CreateDrive(ref volume) => {
-                self.add_drive(disp, volume.clone())?;
-                Ok((true, vec![]))
+                let drive = self.add_drive(disp, volume.clone())?;
+                let actions = PIso::share_drive(drive, false)?;
+                Ok((true, actions))
             }
             action::Action::SnapshotDrive(ref name) => {
                 let report = self.vg.snapshot_volume(name)?;
-                self.add_drive(disp, report)?;
-                Ok((true, vec![]))
+                let drive = self.add_drive(disp, report)?;
+                let actions = PIso::share_drive(drive, false)?;
+                Ok((true, actions))
             }
             action::Action::DeleteDrive(ref name) => {
+                let mut actions = vec![];
                 if let Some(ref mut drive) =
                     self.drives.iter_mut().find(|drive| drive.name() == name)
                 {
+                    actions = PIso::share_drive(drive, true)?;
                     drive.unmount()?;
                 }
                 self.drives.retain(|drive| drive.name() != name);
                 self.vg.delete_volume(&name)?;
-                Ok((true, vec![]))
+                Ok((true, actions))
             }
             _ => Ok((false, vec![])),
         }
diff --git a/pISO/src/vdrive.rs b/pISO/src/vdrive.rs
@@ -152,7 +152,10 @@ impl VirtualDrive {
         ).into())
     }
 
-    pub fn mount_internal(&mut self, disp: &mut DisplayManager) -> Result<()> {
+    pub fn mount_internal<'a, 'b>(
+        &'a mut self,
+        disp: &'b mut DisplayManager,
+    ) -> Result<&'a MountInfo> {
         match self.state {
             MountState::Unmounted => {
                 let volume_path = &self.volume.path.to_string_lossy();
@@ -222,9 +225,12 @@ impl VirtualDrive {
                     isos: isos,
                     loopback_path: loopback_path.to_path_buf(),
                 });
-                Ok(())
+                match &self.state {
+                    &MountState::Internal(ref info) => Ok(info),
+                    _ => unreachable!(),
+                }
             }
-            MountState::Internal(_) => Ok(()),
+            MountState::Internal(ref state) => Ok(state),
             MountState::External(_) => {
                 Err("Attempt to mount_internal while mounted external".into())
             }
@@ -262,7 +268,8 @@ impl VirtualDrive {
             }
             MountState::External(_) => {
                 self.unmount_external()?;
-                self.mount_internal(disp)
+                self.mount_internal(disp)?;
+                Ok(())
             }
         }
     }
diff --git a/pISO/src/version.rs b/pISO/src/version.rs
@@ -1,6 +1,7 @@
 use action;
 use bitmap;
 use controller;
+use display;
 use displaymanager::{DisplayManager, Position, Widget, Window, WindowId};
 use error;
 use font;
@@ -56,14 +57,14 @@ enum VersionState {
 
 pub struct VersionMenu {
     pub window: WindowId,
-    state: VersionState
+    state: VersionState,
 }
 
 impl VersionMenu {
     pub fn new(disp: &mut DisplayManager) -> error::Result<VersionMenu> {
         Ok(VersionMenu {
             window: disp.add_child(Position::Normal)?,
-            state: VersionState::Unselected
+            state: VersionState::Unselected,
         })
     }
 }
@@ -97,8 +98,7 @@ impl input::Input for VersionMenu {
     ) -> error::Result<(bool, Vec<action::Action>)> {
         match *action {
             action::Action::OpenVersion => {
-                let menu =
-                    OpenVersionMenu::new(disp)?;
+                let menu = OpenVersionMenu::new(disp)?;
                 disp.shift_focus(&menu);
                 self.state = VersionState::Selected(menu);
                 Ok((true, vec![]))
@@ -135,10 +135,8 @@ impl Widget for VersionMenu {
     }
 }
 
-
-
 struct OpenVersionMenu {
-    pub window: WindowId
+    pub window: WindowId,
 }
 
 impl OpenVersionMenu {
diff --git a/pISO/src/wifi.rs b/pISO/src/wifi.rs
@@ -22,7 +22,6 @@ const HOSTAPD_TMP_CONF: &'static str = "/tmp/hostapd.conf";
 const WPA_SUPPLICANT_CONF: &'static str = "/etc/wpa_supplicant.conf";
 const WPA_SUPPLICANT_TMP_CONF: &'static str = "/tmp/wpa_supplicant.conf";
 const SMB_CONF: &'static str = "/etc/samba/smb.conf";
-const SMB_TMP_CONF: &'static str = "/tmp/smb.conf";
 const PURE_FTPD_CONF: &'static str = "/etc/pure-ftpd.conf";
 
 #[derive(PartialEq)]
@@ -46,6 +45,10 @@ impl WifiManager {
         }))
     }
 
+    fn is_enabled(&self) -> bool {
+        self.state != WifiState::Uninitialized
+    }
+
     fn enable_wifi(&mut self) -> error::Result<()> {
         if self.state != WifiState::Uninitialized {
             return Ok(());
@@ -87,13 +90,55 @@ impl WifiManager {
             &[&self.config.user.name, &self.config.user.password],
         )?;
 
-        fs::copy(SMB_CONF, SMB_TMP_CONF)?;
-        utils::run_check_output("smbd", &["-D", "-s", SMB_TMP_CONF])?;
-        utils::run_check_output("nmbd", &["-D", "-s", SMB_TMP_CONF])?;
+        // Setup usershare folder
+        fs::create_dir_all("/var/lib/samba/usershares")?;
+        utils::run_check_output("chmod", &["1770", "/var/lib/samba/usershares"])?;
+
+        utils::run_check_output("smbd", &["-D", "-s", SMB_CONF])?;
+        utils::run_check_output("nmbd", &["-D", "-s", SMB_CONF])?;
 
         utils::run_check_output("pure-ftpd", &[PURE_FTPD_CONF])?;
 
         self.state = WifiState::Inactive;
+
+        for entry in fs::read_dir("/mnt")? {
+            let entry = entry?;
+            let path = entry.path();
+            let name = path.file_name()
+                .expect("Partition has no name")
+                .to_string_lossy()
+                .into_owned();
+            self.share_mounted_partition(&name)?;
+        }
+
+        Ok(())
+    }
+
+    fn share_mounted_partition(&mut self, name: &str) -> error::Result<()> {
+        if !self.is_enabled() {
+            return Ok(());
+        }
+
+        let path = "/user-mnt/".to_owned() + name;
+        utils::run_check_output(
+            "net",
+            &[
+                "usershare",
+                "add",
+                name,
+                &path,
+                "",
+                &format!("piso\\{}:F", &self.config.user.name),
+            ],
+        )?;
+        Ok(())
+    }
+
+    fn remove_shared_partition(&mut self, name: &str) -> error::Result<()> {
+        if !self.is_enabled() {
+            return Ok(());
+        }
+        utils::run_check_output("net", &["usershare", "delete", &name])?;
         Ok(())
     }
 
@@ -262,6 +307,14 @@ impl input::Input for WifiMenu {
                 disp.shift_focus(self);
                 Ok((true, vec![]))
             }
+            action::Action::SmbSharePartition(ref name) => {
+                self.manager.lock()?.share_mounted_partition(name)?;
+                Ok((true, vec![]))
+            }
+            action::Action::SmbRemoveShare(ref name) => {
+                self.manager.lock()?.remove_shared_partition(name)?;
+                Ok((true, vec![]))
+            }
             _ => Ok((false, vec![])),
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -38,5 +38,8 @@ pub enum Action {`
`38`	`38`	`FlipDisplay,`
`39`	`39`
`40`	`40`	`OpenVersion,`
`41`		`- CloseVersion`
	`41`	`+ CloseVersion,`
	`42`	`+`
	`43`	`+ SmbSharePartition(String),`
	`44`	`+ SmbRemoveShare(String),`
`42`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,10 @@ impl VirtualDrive {`
`152`	`152`	`).into())`
`153`	`153`	`}`
`154`	`154`
`155`		`- pub fn mount_internal(&mut self, disp: &mut DisplayManager) -> Result<()> {`
	`155`	`+ pub fn mount_internal<'a, 'b>(`
	`156`	`+ &'a mut self,`
	`157`	`+ disp: &'b mut DisplayManager,`
	`158`	`+ ) -> Result<&'a MountInfo> {`
`156`	`159`	`match self.state {`
`157`	`160`	`MountState::Unmounted => {`
`158`	`161`	`let volume_path = &self.volume.path.to_string_lossy();`
`@@ -222,9 +225,12 @@ impl VirtualDrive {`
`222`	`225`	`isos: isos,`
`223`	`226`	`loopback_path: loopback_path.to_path_buf(),`
`224`	`227`	`});`
`225`		`- Ok(())`
	`228`	`+ match &self.state {`
	`229`	`+ &MountState::Internal(ref info) => Ok(info),`
	`230`	`+ _ => unreachable!(),`
	`231`	`+ }`
`226`	`232`	`}`
`227`		`- MountState::Internal(_) => Ok(()),`
	`233`	`+ MountState::Internal(ref state) => Ok(state),`
`228`	`234`	`MountState::External(_) => {`
`229`	`235`	`Err("Attempt to mount_internal while mounted external".into())`
`230`	`236`	`}`
`@@ -262,7 +268,8 @@ impl VirtualDrive {`
`262`	`268`	`}`
`263`	`269`	`MountState::External(_) => {`
`264`	`270`	`self.unmount_external()?;`
`265`		`- self.mount_internal(disp)`
	`271`	`+ self.mount_internal(disp)?;`
	`272`	`+ Ok(())`
`266`	`273`	`}`
`267`	`274`	`}`
`268`	`275`	`}`