Merge e38f5b8 into 9c63d20

backhand-cli/src/bin/unsquashfs.rs

@@ -22,6 +22,7 @@ use indicatif::{HumanDuration, ProgressBar, ProgressStyle};
 use nix::libc::geteuid;
 use nix::sys::stat::{dev_t, mknod, mode_t, umask, utimensat, utimes, Mode, SFlag, UtimensatFlags};
 use nix::sys::time::{TimeSpec, TimeVal};
+use nix::unistd::mkfifo;
 use rayon::prelude::*;
 use std::time::{Duration, Instant};
 
@@ -623,6 +624,54 @@ fn extract_all<'a, S: ParallelIterator<Item = &'a Node<SquashfsFileReader>>>(
                     }
                 }
             }
+            InnerNode::NamedPipe => {
+                match mkfifo(
+                    &filepath,
+                    Mode::from_bits(mode_t::from(node.header.permissions)).unwrap(),
+                ) {
+                    Ok(_) => {
+                        if args.info && !args.quiet {
+                            created(&pb, filepath.to_str().unwrap());
+                        }
+
+                        set_attributes(&pb, args, &filepath, &node.header, root_process, true);
+                    }
+                    Err(_) => {
+                        if args.info && !args.quiet {
+                            created(&pb, filepath.to_str().unwrap());
+                        }
+                        let mut p = processing.lock().unwrap();
+                        p.remove(fullpath);
+                        drop(p);
+                        return;
+                    }
+                }
+            }
+            InnerNode::Socket => {
+                match mknod(
+                    &filepath,
+                    SFlag::S_IFSOCK,
+                    Mode::from_bits(mode_t::from(node.header.permissions)).unwrap(),
+                    dev_t::from(0_u64),
+                ) {
+                    Ok(_) => {
+                        if args.info && !args.quiet {
+                            created(&pb, filepath.to_str().unwrap());
+                        }
+
+                        set_attributes(&pb, args, &filepath, &node.header, root_process, true);
+                    }
+                    Err(_) => {
+                        if args.info && !args.quiet {
+                            created(&pb, filepath.to_str().unwrap());
+                            let mut p = processing.lock().unwrap();
+                            p.remove(fullpath);
+                            drop(p);
+                        }
+                        return;
+                    }
+                }
+            }
         }
         let mut p = processing.lock().unwrap();
         p.remove(fullpath);

backhand-test/tests/test.rs

@@ -453,3 +453,22 @@ fn test_few_dirs_many_files() {
         only_read(&asset_defs, FILE_NAME, TEST_PATH, 0);
     }
 }
+
+#[test]
+#[cfg(any(feature = "gzip", feature = "gzip-zune-inflate"))]
+fn test_socket_fifo() {
+    const FILE_NAME: &str = "squashfs_v4.specfile.bin";
+    let asset_defs = [TestAssetDef {
+        filename: FILE_NAME.to_string(),
+        hash: "d27f2e4baf57df961b9aa7298ac390a54fd0d2c904bf1d4baaee49cbdd0a93f1".to_string(),
+        url: format!("https://wcampbell.dev/squashfs/testing/test_socket_fifo/{FILE_NAME}"),
+    }];
+
+    const TEST_PATH: &str = "test-assets/socket_fifo";
+
+    if has_gzip_feature() {
+        full_test(&asset_defs, FILE_NAME, TEST_PATH, 0, Verify::Extract, true);
+    } else {
+        only_read(&asset_defs, FILE_NAME, TEST_PATH, 0);
+    }
+}

backhand/src/entry.rs

@@ -5,8 +5,8 @@ use std::os::unix::prelude::OsStrExt;
 use crate::data::Added;
 use crate::dir::{Dir, DirEntry};
 use crate::inode::{
-    BasicDeviceSpecialFile, BasicDirectory, BasicFile, BasicSymlink, ExtendedDirectory, Inode,
-    InodeHeader, InodeId, InodeInner,
+    BasicDeviceSpecialFile, BasicDirectory, BasicFile, BasicSymlink, ExtendedDirectory, IPCNode,
+    Inode, InodeHeader, InodeId, InodeInner,
 };
 use crate::kinds::Kind;
 use crate::metadata::MetadataWriter;
@@ -235,6 +235,64 @@ impl<'a> Entry<'a> {
 
         block_inode.to_bytes(node_path.as_bytes(), inode_writer, superblock, kind)
     }
+
+    /// Write data and metadata for named pipe node
+    #[allow(clippy::too_many_arguments)]
+    pub fn named_pipe(
+        node_path: &'a OsStr,
+        header: NodeHeader,
+        inode: u32,
+        inode_writer: &mut MetadataWriter,
+        superblock: &SuperBlock,
+        kind: &Kind,
+        id_table: &[Id],
+    ) -> Self {
+        let uid = id_table.iter().position(|a| a.num == header.uid).unwrap() as u16;
+        let gid = id_table.iter().position(|a| a.num == header.gid).unwrap() as u16;
+        let header = InodeHeader {
+            inode_number: inode,
+            uid,
+            gid,
+            permissions: header.permissions,
+            mtime: header.mtime,
+        };
+        let char_inode = Inode::new(
+            InodeId::BasicNamedPipe,
+            header,
+            InodeInner::BasicNamedPipe(IPCNode { link_count: 0x1 }),
+        );
+
+        char_inode.to_bytes(node_path.as_bytes(), inode_writer, superblock, kind)
+    }
+
+    /// Write data and metadata for socket
+    #[allow(clippy::too_many_arguments)]
+    pub fn socket(
+        node_path: &'a OsStr,
+        header: NodeHeader,
+        inode: u32,
+        inode_writer: &mut MetadataWriter,
+        superblock: &SuperBlock,
+        kind: &Kind,
+        id_table: &[Id],
+    ) -> Self {
+        let uid = id_table.iter().position(|a| a.num == header.uid).unwrap() as u16;
+        let gid = id_table.iter().position(|a| a.num == header.gid).unwrap() as u16;
+        let header = InodeHeader {
+            inode_number: inode,
+            uid,
+            gid,
+            permissions: header.permissions,
+            mtime: header.mtime,
+        };
+        let char_inode = Inode::new(
+            InodeId::BasicSocket,
+            header,
+            InodeInner::BasicSocket(IPCNode { link_count: 0x1 }),
+        );
+
+        char_inode.to_bytes(node_path.as_bytes(), inode_writer, superblock, kind)
+    }
 }
 
 impl<'a> fmt::Debug for Entry<'a> {

backhand/src/filesystem/node.rs

@@ -83,6 +83,8 @@ pub enum InnerNode<T> {
     Dir(SquashfsDir),
     CharacterDevice(SquashfsCharacterDevice),
     BlockDevice(SquashfsBlockDevice),
+    NamedPipe,
+    Socket,
 }
 
 /// Unread file for filesystem

backhand/src/filesystem/reader.rs

@@ -40,6 +40,8 @@ use crate::{Node, Squashfs, SquashfsFileReader};
 ///         InnerNode::Dir(_) => (),
 ///         InnerNode::CharacterDevice(_) => (),
 ///         InnerNode::BlockDevice(_) => (),
+///         InnerNode::NamedPipe => (),
+///         InnerNode::Socket => (),
 ///     }
 /// }
 /// ```

backhand/src/filesystem/writer.rs

@@ -210,6 +210,8 @@ impl<'a, 'b, 'c> FilesystemWriter<'a, 'b, 'c> {
                     InnerNode::Dir(x) => InnerNode::Dir(*x),
                     InnerNode::CharacterDevice(x) => InnerNode::CharacterDevice(*x),
                     InnerNode::BlockDevice(x) => InnerNode::BlockDevice(*x),
+                    InnerNode::NamedPipe => InnerNode::NamedPipe,
+                    InnerNode::Socket => InnerNode::Socket,
                 };
                 Node { fullpath: node.fullpath.clone(), header: node.header, inner }
             })
@@ -531,6 +533,28 @@ impl<'a, 'b, 'c> FilesystemWriter<'a, 'b, 'c> {
                     id_table,
                 ))
             }
+            InnerNode::NamedPipe => {
+                return Ok(Entry::named_pipe(
+                    filename,
+                    node.header,
+                    node_id.get().try_into().unwrap(),
+                    inode_writer,
+                    superblock,
+                    kind,
+                    id_table,
+                ))
+            }
+            InnerNode::Socket => {
+                return Ok(Entry::socket(
+                    filename,
+                    node.header,
+                    node_id.get().try_into().unwrap(),
+                    inode_writer,
+                    superblock,
+                    kind,
+                    id_table,
+                ))
+            }
             // if dir, fall through
             InnerNode::Dir(_) => (),
         };

backhand/src/inode.rs

@@ -72,6 +72,8 @@ pub enum InodeId {
     BasicSymlink         = 3,
     BasicBlockDevice     = 4,
     BasicCharacterDevice = 5,
+    BasicNamedPipe       = 6, // aka FIFO
+    BasicSocket          = 7,
     ExtendedDirectory    = 8,
     ExtendedFile         = 9,
     // TODO:
@@ -114,6 +116,12 @@ pub enum InodeInner {
     #[deku(id = "InodeId::BasicCharacterDevice")]
     BasicCharacterDevice(BasicDeviceSpecialFile),
 
+    #[deku(id = "InodeId::BasicNamedPipe")]
+    BasicNamedPipe(IPCNode),
+
+    #[deku(id = "InodeId::BasicSocket")]
+    BasicSocket(IPCNode),
+
     #[deku(id = "InodeId::ExtendedDirectory")]
     ExtendedDirectory(ExtendedDirectory),
 
@@ -244,3 +252,9 @@ pub struct BasicDeviceSpecialFile {
     pub link_count: u32,
     pub device_number: u32,
 }
+
+#[derive(Debug, DekuRead, DekuWrite, Clone, PartialEq, Eq)]
+#[deku(endian = "endian", ctx = "endian: deku::ctx::Endian")]
+pub struct IPCNode {
+    pub link_count: u32,
+}

backhand/src/squashfs.rs

@@ -554,6 +554,8 @@ impl<'b> Squashfs<'b> {
                             let device_number = self.block_device(found_inode)?;
                             InnerNode::BlockDevice(SquashfsBlockDevice { device_number })
                         }
+                        InodeId::BasicNamedPipe => InnerNode::NamedPipe,
+                        InodeId::BasicSocket => InnerNode::Socket,
                         InodeId::ExtendedFile => {
                             return Err(BackhandError::UnsupportedInode(found_inode.inner.clone()))
                         }