src/tempfile.rs - platform/external/rust/crates/vmm-sys-util - Git at Google

 // Copyright 2017 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 //
 // SPDX-License-Identifier: BSD-3-Clause

 //! Struct for handling temporary files as well as any cleanup required.
 //!
 //! The temporary files will be created with a name available as well as having
 //! an exposed `fs::File` for reading/writing.
 //!
 //! The file will be removed when the object goes out of scope.
 //!
 //! # Examples
 //!
 //! ```
 //! use std::env::temp_dir;
 //! use std::io::Write;
 //! use std::path::{Path, PathBuf};
 //! use vmm_sys_util::tempfile::TempFile;
 //!
 //! let mut prefix = temp_dir();
 //! prefix.push("tempfile");
 //! let t = TempFile::new_with_prefix(prefix).unwrap();
 //! let mut f = t.as_file();
 //! f.write_all(b"hello world").unwrap();
 //! f.sync_all().unwrap();

 use std::env::temp_dir;
 use std::ffi::OsStr;
 use std::fs;
 use std::fs::File;
 use std::path::{Path, PathBuf};

 use libc;

 use crate::errno::{errno_result, Error, Result};

 /// Wrapper for working with temporary files.
 ///
 /// The file will be maintained for the lifetime of the `TempFile` object.
 #[derive(Debug)]
 pub struct TempFile {
     path: PathBuf,
     file: Option<File>,
 }

 impl TempFile {
     /// Creates the TempFile using a prefix.
     ///
     /// # Arguments
     ///
     /// `prefix`: The path and filename where to create the temporary file. Six
     /// random alphanumeric characters will be added to the end of this to form
     /// the filename.
     #[cfg(unix)]
     pub fn new_with_prefix<P: AsRef<OsStr>>(prefix: P) -> Result<TempFile> {
         use std::ffi::CString;
         use std::os::unix::{ffi::OsStrExt, io::FromRawFd};

         let mut os_fname = prefix.as_ref().to_os_string();
         os_fname.push("XXXXXX");

         let c_tempname = CString::new(os_fname.as_bytes()).map_err(|_| Error::new(libc::EINVAL))?;
         let raw_tempname = c_tempname.into_raw();

         // SAFETY: Safe because `c_tempname` is a null-terminated string, as it originates from
         // `CString::into_raw`.
         let ret = unsafe { libc::mkstemp(raw_tempname) };

         // SAFETY: `raw_tempname` originates from `CString::into_raw`.
         let c_tempname = unsafe { CString::from_raw(raw_tempname) };

         let fd = match ret {
             -1 => return errno_result(),
             _ => ret,
         };

         let os_tempname = OsStr::from_bytes(c_tempname.as_bytes());

         // SAFETY: Safe because we checked `fd != -1` above and we uniquely own the file
         // descriptor. This `fd` will be freed etc when `File` and thus
         // `TempFile` goes out of scope.
         let file = unsafe { File::from_raw_fd(fd) };

         Ok(TempFile {
             path: PathBuf::from(os_tempname),
             file: Some(file),
         })
     }

     /// Creates the TempFile using a prefix.
     ///
     /// # Arguments
     ///
     /// `prefix`: The path and filename where to create the temporary file. Six
     /// random alphanumeric characters will be added to the end of this to form
     /// the filename.
     #[cfg(windows)]
     pub fn new_with_prefix<P: AsRef<OsStr>>(prefix: P) -> Result<TempFile> {
         use crate::rand::rand_alphanumerics;
         use std::fs::OpenOptions;

         let file_path_str = format!(
             "{}{}",
             prefix.as_ref().to_str().unwrap_or_default(),
             rand_alphanumerics(6).to_str().unwrap_or_default()
         );
         let file_path_buf = PathBuf::from(&file_path_str);

         let file = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
             .truncate(true)
             .open(file_path_buf.as_path())?;

         Ok(TempFile {
             path: file_path_buf,
             file: Some(file),
         })
     }

     /// Creates the TempFile inside a specific location.
     ///
     /// # Arguments
     ///
     /// `path`: The path where to create a temporary file with a filename formed from
     /// six random alphanumeric characters.
     pub fn new_in(path: &Path) -> Result<Self> {
         let mut path_buf = path.canonicalize().unwrap();
         // This `push` adds a trailing slash ("/whatever/path" -> "/whatever/path/").
         // This is safe for paths with an already existing trailing slash.
         path_buf.push("");
         let temp_file = TempFile::new_with_prefix(path_buf.as_path())?;
         Ok(temp_file)
     }

     /// Creates the TempFile.
     ///
     /// Creates a temporary file inside `$TMPDIR` if set, otherwise inside `/tmp`.
     /// The filename will consist of six random alphanumeric characters.
     pub fn new() -> Result<Self> {
         let in_tmp_dir = temp_dir();
         let temp_file = TempFile::new_in(in_tmp_dir.as_path())?;
         Ok(temp_file)
     }

     /// Removes the temporary file.
     ///
     /// Calling this is optional as dropping a `TempFile` object will also
     /// remove the file.  Calling remove explicitly allows for better error
     /// handling.
     pub fn remove(&mut self) -> Result<()> {
         fs::remove_file(&self.path).map_err(Error::from)
     }

     /// Returns the path to the file if the `TempFile` object that is wrapping the file
     /// is still in scope.
     ///
     /// If we remove the file by explicitly calling [`remove`](#method.remove),
     /// `as_path()` can still be used to return the path to that file (even though that
     /// path does not point at an existing entity anymore).
     /// Calling `as_path()` after `remove()` is useful, for example, when you need a
     /// random path string, but don't want an actual resource at that path.
     pub fn as_path(&self) -> &Path {
         &self.path
     }

     /// Returns a reference to the File.
     pub fn as_file(&self) -> &File {
         // It's safe to unwrap because `file` can be `None` only after calling `into_file`
         // which consumes this object.
         self.file.as_ref().unwrap()
     }

     /// Consumes the TempFile, returning the wrapped file.
     ///
     /// This also removes the file from the system. The file descriptor remains opened and
     /// it can be used until the returned file is dropped.
     pub fn into_file(mut self) -> File {
         self.file.take().unwrap()
     }
 }

 impl Drop for TempFile {
     fn drop(&mut self) {
         let _ = self.remove();
     }
 }

 #[cfg(test)]
 mod tests {
     use super::*;
     use std::io::{Read, Write};

     #[test]
     fn test_create_file_with_prefix() {
         fn between(lower: u8, upper: u8, to_check: u8) -> bool {
             (to_check >= lower) && (to_check <= upper)
         }

         let mut prefix = temp_dir();
         prefix.push("asdf");
         let t = TempFile::new_with_prefix(&prefix).unwrap();
         let path = t.as_path().to_owned();

         // Check filename exists
         assert!(path.is_file());

         // Check filename is in the correct location
         assert!(path.starts_with(temp_dir()));

         // Check filename has random added
         assert_eq!(path.file_name().unwrap().to_string_lossy().len(), 10);

         // Check filename has only ascii letters / numbers
         for n in path.file_name().unwrap().to_string_lossy().bytes() {
             assert!(between(b'0', b'9', n) || between(b'a', b'z', n) || between(b'A', b'Z', n));
         }

         // Check we can write to the file
         let mut f = t.as_file();
         f.write_all(b"hello world").unwrap();
         f.sync_all().unwrap();
         assert_eq!(f.metadata().unwrap().len(), 11);
     }

     #[test]
     fn test_create_file_new() {
         let t = TempFile::new().unwrap();
         let path = t.as_path().to_owned();

         // Check filename is in the correct location
         assert!(path.starts_with(temp_dir().canonicalize().unwrap()));
     }

     #[test]
     fn test_create_file_new_in() {
         let t = TempFile::new_in(temp_dir().as_path()).unwrap();
         let path = t.as_path().to_owned();

         // Check filename exists
         assert!(path.is_file());

         // Check filename is in the correct location
         assert!(path.starts_with(temp_dir().canonicalize().unwrap()));

         let t = TempFile::new_in(temp_dir().as_path()).unwrap();
         let path = t.as_path().to_owned();

         // Check filename is in the correct location
         assert!(path.starts_with(temp_dir().canonicalize().unwrap()));
     }

     #[test]
     fn test_remove_file() {
         let mut prefix = temp_dir();
         prefix.push("asdf");

         let mut t = TempFile::new_with_prefix(prefix).unwrap();
         let path = t.as_path().to_owned();

         // Check removal.
         assert!(t.remove().is_ok());
         assert!(!path.exists());

         // Calling `as_path()` after the file was removed is allowed.
         let path_2 = t.as_path().to_owned();
         assert_eq!(path, path_2);

         // Check trying to remove a second time returns an error.
         assert!(t.remove().is_err());
     }

     #[test]
     fn test_drop_file() {
         let mut prefix = temp_dir();
         prefix.push("asdf");

         let t = TempFile::new_with_prefix(prefix).unwrap();
         let path = t.as_path().to_owned();

         assert!(path.starts_with(temp_dir()));
         drop(t);
         assert!(!path.exists());
     }

     #[test]
     fn test_into_file() {
         let mut prefix = temp_dir();
         prefix.push("asdf");

         let text = b"hello world";
         let temp_file = TempFile::new_with_prefix(prefix).unwrap();
         let path = temp_file.as_path().to_owned();
         fs::write(path, text).unwrap();

         let mut file = temp_file.into_file();
         let mut buf: Vec<u8> = Vec::new();
         file.read_to_end(&mut buf).unwrap();
         assert_eq!(buf, text);
     }
 }
	// Copyright 2017 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE-BSD-3-Clause file.
	//
	// SPDX-License-Identifier: BSD-3-Clause

	//! Struct for handling temporary files as well as any cleanup required.
	//!
	//! The temporary files will be created with a name available as well as having
	//! an exposed `fs::File` for reading/writing.
	//!
	//! The file will be removed when the object goes out of scope.
	//!
	//! # Examples
	//!
	//! ```
	//! use std::env::temp_dir;
	//! use std::io::Write;
	//! use std::path::{Path, PathBuf};
	//! use vmm_sys_util::tempfile::TempFile;
	//!
	//! let mut prefix = temp_dir();
	//! prefix.push("tempfile");
	//! let t = TempFile::new_with_prefix(prefix).unwrap();
	//! let mut f = t.as_file();
	//! f.write_all(b"hello world").unwrap();
	//! f.sync_all().unwrap();

	use std::env::temp_dir;
	use std::ffi::OsStr;
	use std::fs;
	use std::fs::File;
	use std::path::{Path, PathBuf};

	use libc;

	use crate::errno::{errno_result, Error, Result};

	/// Wrapper for working with temporary files.
	///
	/// The file will be maintained for the lifetime of the `TempFile` object.
	#[derive(Debug)]
	pub struct TempFile {
	path: PathBuf,
	file: Option<File>,
	}

	impl TempFile {
	/// Creates the TempFile using a prefix.
	///
	/// # Arguments
	///
	/// `prefix`: The path and filename where to create the temporary file. Six
	/// random alphanumeric characters will be added to the end of this to form
	/// the filename.
	#[cfg(unix)]
	pub fn new_with_prefix<P: AsRef<OsStr>>(prefix: P) -> Result<TempFile> {
	use std::ffi::CString;
	use std::os::unix::{ffi::OsStrExt, io::FromRawFd};

	let mut os_fname = prefix.as_ref().to_os_string();
	os_fname.push("XXXXXX");

	let c_tempname = CString::new(os_fname.as_bytes()).map_err(\|_\| Error::new(libc::EINVAL))?;
	let raw_tempname = c_tempname.into_raw();

	// SAFETY: Safe because `c_tempname` is a null-terminated string, as it originates from
	// `CString::into_raw`.
	let ret = unsafe { libc::mkstemp(raw_tempname) };

	// SAFETY: `raw_tempname` originates from `CString::into_raw`.
	let c_tempname = unsafe { CString::from_raw(raw_tempname) };

	let fd = match ret {
	-1 => return errno_result(),
	_ => ret,
	};

	let os_tempname = OsStr::from_bytes(c_tempname.as_bytes());

	// SAFETY: Safe because we checked `fd != -1` above and we uniquely own the file
	// descriptor. This `fd` will be freed etc when `File` and thus
	// `TempFile` goes out of scope.
	let file = unsafe { File::from_raw_fd(fd) };

	Ok(TempFile {
	path: PathBuf::from(os_tempname),
	file: Some(file),
	})
	}

	/// Creates the TempFile using a prefix.
	///
	/// # Arguments
	///
	/// `prefix`: The path and filename where to create the temporary file. Six
	/// random alphanumeric characters will be added to the end of this to form
	/// the filename.
	#[cfg(windows)]
	pub fn new_with_prefix<P: AsRef<OsStr>>(prefix: P) -> Result<TempFile> {
	use crate::rand::rand_alphanumerics;
	use std::fs::OpenOptions;

	let file_path_str = format!(
	"{}{}",
	prefix.as_ref().to_str().unwrap_or_default(),
	rand_alphanumerics(6).to_str().unwrap_or_default()
	);
	let file_path_buf = PathBuf::from(&file_path_str);

	let file = OpenOptions::new()
	.read(true)
	.write(true)
	.create(true)
	.truncate(true)
	.open(file_path_buf.as_path())?;

	Ok(TempFile {
	path: file_path_buf,
	file: Some(file),
	})
	}

	/// Creates the TempFile inside a specific location.
	///
	/// # Arguments
	///
	/// `path`: The path where to create a temporary file with a filename formed from
	/// six random alphanumeric characters.
	pub fn new_in(path: &Path) -> Result<Self> {
	let mut path_buf = path.canonicalize().unwrap();
	// This `push` adds a trailing slash ("/whatever/path" -> "/whatever/path/").
	// This is safe for paths with an already existing trailing slash.
	path_buf.push("");
	let temp_file = TempFile::new_with_prefix(path_buf.as_path())?;
	Ok(temp_file)
	}

	/// Creates the TempFile.
	///
	/// Creates a temporary file inside `$TMPDIR` if set, otherwise inside `/tmp`.
	/// The filename will consist of six random alphanumeric characters.
	pub fn new() -> Result<Self> {
	let in_tmp_dir = temp_dir();
	let temp_file = TempFile::new_in(in_tmp_dir.as_path())?;
	Ok(temp_file)
	}

	/// Removes the temporary file.
	///
	/// Calling this is optional as dropping a `TempFile` object will also
	/// remove the file. Calling remove explicitly allows for better error
	/// handling.
	pub fn remove(&mut self) -> Result<()> {
	fs::remove_file(&self.path).map_err(Error::from)
	}

	/// Returns the path to the file if the `TempFile` object that is wrapping the file
	/// is still in scope.
	///
	/// If we remove the file by explicitly calling [`remove`](#method.remove),
	/// `as_path()` can still be used to return the path to that file (even though that
	/// path does not point at an existing entity anymore).
	/// Calling `as_path()` after `remove()` is useful, for example, when you need a
	/// random path string, but don't want an actual resource at that path.
	pub fn as_path(&self) -> &Path {
	&self.path
	}

	/// Returns a reference to the File.
	pub fn as_file(&self) -> &File {
	// It's safe to unwrap because `file` can be `None` only after calling `into_file`
	// which consumes this object.
	self.file.as_ref().unwrap()
	}

	/// Consumes the TempFile, returning the wrapped file.
	///
	/// This also removes the file from the system. The file descriptor remains opened and
	/// it can be used until the returned file is dropped.
	pub fn into_file(mut self) -> File {
	self.file.take().unwrap()
	}
	}

	impl Drop for TempFile {
	fn drop(&mut self) {
	let _ = self.remove();
	}
	}

	#[cfg(test)]
	mod tests {
	use super::*;
	use std::io::{Read, Write};

	#[test]
	fn test_create_file_with_prefix() {
	fn between(lower: u8, upper: u8, to_check: u8) -> bool {
	(to_check >= lower) && (to_check <= upper)
	}

	let mut prefix = temp_dir();
	prefix.push("asdf");
	let t = TempFile::new_with_prefix(&prefix).unwrap();
	let path = t.as_path().to_owned();

	// Check filename exists
	assert!(path.is_file());

	// Check filename is in the correct location
	assert!(path.starts_with(temp_dir()));

	// Check filename has random added
	assert_eq!(path.file_name().unwrap().to_string_lossy().len(), 10);

	// Check filename has only ascii letters / numbers
	for n in path.file_name().unwrap().to_string_lossy().bytes() {
	assert!(between(b'0', b'9', n) \|\| between(b'a', b'z', n) \|\| between(b'A', b'Z', n));
	}

	// Check we can write to the file
	let mut f = t.as_file();
	f.write_all(b"hello world").unwrap();
	f.sync_all().unwrap();
	assert_eq!(f.metadata().unwrap().len(), 11);
	}

	#[test]
	fn test_create_file_new() {
	let t = TempFile::new().unwrap();
	let path = t.as_path().to_owned();

	// Check filename is in the correct location
	assert!(path.starts_with(temp_dir().canonicalize().unwrap()));
	}

	#[test]
	fn test_create_file_new_in() {
	let t = TempFile::new_in(temp_dir().as_path()).unwrap();
	let path = t.as_path().to_owned();

	// Check filename exists
	assert!(path.is_file());

	// Check filename is in the correct location
	assert!(path.starts_with(temp_dir().canonicalize().unwrap()));

	let t = TempFile::new_in(temp_dir().as_path()).unwrap();
	let path = t.as_path().to_owned();

	// Check filename is in the correct location
	assert!(path.starts_with(temp_dir().canonicalize().unwrap()));
	}

	#[test]
	fn test_remove_file() {
	let mut prefix = temp_dir();
	prefix.push("asdf");

	let mut t = TempFile::new_with_prefix(prefix).unwrap();
	let path = t.as_path().to_owned();

	// Check removal.
	assert!(t.remove().is_ok());
	assert!(!path.exists());

	// Calling `as_path()` after the file was removed is allowed.
	let path_2 = t.as_path().to_owned();
	assert_eq!(path, path_2);

	// Check trying to remove a second time returns an error.
	assert!(t.remove().is_err());
	}

	#[test]
	fn test_drop_file() {
	let mut prefix = temp_dir();
	prefix.push("asdf");

	let t = TempFile::new_with_prefix(prefix).unwrap();
	let path = t.as_path().to_owned();

	assert!(path.starts_with(temp_dir()));
	drop(t);
	assert!(!path.exists());
	}

	#[test]
	fn test_into_file() {
	let mut prefix = temp_dir();
	prefix.push("asdf");

	let text = b"hello world";
	let temp_file = TempFile::new_with_prefix(prefix).unwrap();
	let path = temp_file.as_path().to_owned();
	fs::write(path, text).unwrap();

	let mut file = temp_file.into_file();
	let mut buf: Vec<u8> = Vec::new();
	file.read_to_end(&mut buf).unwrap();
	assert_eq!(buf, text);
	}
	}