utils: Make SealedString take a &CStr instead of a CString

It only uses it to pass it to a syscall, so it doesn’t need ownership of
it.

Author: linkmauve

src/input/keyboard/keymap_file.rs

@@ -21,9 +21,8 @@ pub struct KeymapFile {
 impl KeymapFile {
     /// Turn the keymap into a string using KEYMAP_FORMAT_TEXT_V1, create a sealed file for it, and store the string
     pub fn new(keymap: &Keymap) -> Self {
-        let name = CString::new("smithay-keymap").unwrap();
         let keymap = keymap.get_as_string(KEYMAP_FORMAT_TEXT_V1);
-        let sealed = SealedFile::with_content(name, CString::new(keymap.as_str()).unwrap());
+        let sealed = SealedFile::with_content(c"smithay-keymap", CString::new(keymap.as_str()).unwrap());
 
         if let Err(err) = sealed.as_ref() {
             error!("Error when creating sealed keymap file: {}", err);
@@ -42,8 +41,7 @@ impl KeymapFile {
     pub(crate) fn change_keymap(&mut self, keymap: &Keymap) {
         let keymap = keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1);
 
-        let name = CString::new("smithay-keymap-file").unwrap();
-        let sealed = SealedFile::with_content(name, CString::new(keymap.clone()).unwrap());
+        let sealed = SealedFile::with_content(c"smithay-keymap-file", CString::new(keymap.clone()).unwrap());
 
         if let Err(err) = sealed.as_ref() {
             error!("Error when creating sealed keymap file: {}", err);

src/utils/sealed_file.rs

@@ -4,7 +4,7 @@
 //! information such as keymaps without them being able to write to the handle.
 
 use std::{
-    ffi::CString,
+    ffi::{CStr, CString},
     fs::File,
     io::Write,
     os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd},
@@ -17,16 +17,16 @@ pub(crate) struct SealedFile {
 }
 
 impl SealedFile {
-    pub fn with_content(name: CString, contents: CString) -> Result<Self, std::io::Error> {
+    pub fn with_content(name: &CStr, contents: CString) -> Result<Self, std::io::Error> {
         Self::with_data(name, contents.as_bytes_with_nul())
     }
 
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "android"))]
-    pub fn with_data(name: CString, data: &[u8]) -> Result<Self, std::io::Error> {
+    pub fn with_data(name: &CStr, data: &[u8]) -> Result<Self, std::io::Error> {
         use rustix::fs::{MemfdFlags, SealFlags};
         use std::io::Seek;
 
-        let fd = rustix::fs::memfd_create(&name, MemfdFlags::CLOEXEC | MemfdFlags::ALLOW_SEALING)?;
+        let fd = rustix::fs::memfd_create(name, MemfdFlags::CLOEXEC | MemfdFlags::ALLOW_SEALING)?;
 
         let mut file: File = fd.into();
         file.write_all(data)?;
@@ -46,7 +46,7 @@ impl SealedFile {
     }
 
     #[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "android")))]
-    pub fn with_data(name: CString, data: &[u8]) -> Result<Self, std::io::Error> {
+    pub fn with_data(name: &CStr, data: &[u8]) -> Result<Self, std::io::Error> {
         use rand::{distributions::Alphanumeric, Rng};
         use rustix::{
             io::Errno,
@@ -59,7 +59,7 @@ impl SealedFile {
         // loop a couple times if it exists.
         let mut n = 0;
         let (shm_name, mut file) = loop {
-            let mut shm_name = name.as_bytes().to_owned();
+            let mut shm_name = name.to_bytes().to_owned();
             shm_name.push(b'-');
             shm_name.extend((0..7).map(|_| rng.sample(Alphanumeric)));
             let fd = rustix::shm::shm_open(

src/wayland/dmabuf/mod.rs

@@ -189,7 +189,6 @@ mod dispatch;
 
 use std::{
     collections::HashMap,
-    ffi::CString,
     ops::Sub,
     os::unix::io::AsFd,
     sync::{
@@ -397,8 +396,7 @@ impl DmabufFeedbackBuilder {
             .flat_map(DmabufFeedbackFormat::to_ne_bytes)
             .collect::<Vec<_>>();
 
-        let name = CString::new("smithay-dmabuffeedback-format-table").unwrap();
-        let format_table_file = SealedFile::with_data(name, &formats)?;
+        let format_table_file = SealedFile::with_data(c"smithay-dmabuffeedback-format-table", &formats)?;
 
         // remove all formats from the main tranche that are already covered
         // by a preference tranche