Comportamiento de archivos temporales de Windows: ¿el sistema los elimina?

Question

mediante .NET Framework que tienen la opción de crear archivos temporales con

Path.GetTempFileName(); 

El MSDN no nos dice lo que ocurre con los archivos temporales. Recuerdo haber leído en alguna parte que el SO los borra cuando se reinicia. ¿Es esto cierto?

Si el SO no elimina los archivos, ¿por qué se llaman temporales? Son archivos normales en un directorio normal.

Answer 1

La respuesta corta: no se eliminan.

La respuesta larga: El Path.GetTempFileName() método administrado llama el nativo método Win32API GetTempFileName(), así:

//actual .NET 2.0 decompiled code 
// .NET Reflector rocks for looking at plumbing 
public static string GetTempFileName() 
{ 
    string tempPath = GetTempPath(); 
    new FileIOPermission(FileIOPermissionAccess.Write, tempPath).Demand(); 
    StringBuilder tmpFileName = new StringBuilder(260); 
    if (Win32Native.GetTempFileName(tempPath, "tmp", 0, tmpFileName) == 0) 
    { 
     __Error.WinIOError(); 
    } 
    return tmpFileName.ToString(); 
} 

La documentación de los estados de métodos nativos:

archivos temporales cuyos nombres tienen creado por esta función no se eliminan automáticamente. Para eliminar estos archivos, llame a DeleteFile.

he encontrado un gran artículo llamado "Those pesky temp files" (Archivado de octubre de 2007) que parte desde lo básico y toca algunos problemas menos obvios de manejo de archivos temporales, como:

• Cómo hacer que el archivo es suprimido (incluso si la aplicación se bloquea pista:! FileOption.DeleteOnClose y permitir que el acuerdo del núcleo con él)
• ¿Cómo obtener la política de almacenamiento en caché correcta para el archivo, para mejorar el rendimiento (pista: FileAttributes.Temporary)
• Cómo asegurarse de que el contenido s del archivo de permanecer seguro, debido a que:
  • el nombre del archivo es aún más predecible con el método de gestión que con el
  • el archivo temporal no administrado se crea, entonces cerrado, se obtiene la ruta de acceso a (solo para abrirlo de nuevo), dejando así una pequeña ventana de oportunidad para que los códigos/usuarios maliciosos se apropien del archivo.

C# Código del artículo:

using System; 
using System.IO; 
using System.Security.Permissions; 
using System.Security.Principal; 
using System.Security.AccessControl; 

public static class PathUtility 
{ 
    private const int defaultBufferSize = 0x1000; // 4KB 

#region GetSecureDeleteOnCloseTempFileStream 

    /// <summary> 
    /// Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream. 
    /// </summary> 
    /// <remarks> 
    /// <para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para> 
    /// <para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para> 
    /// <para>The file is created as a zero-byte file in the system's temporary folder.</para> 
    /// <para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para> 
    /// <para>The file sharing is set to none.</para> 
    /// <para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para> 
    /// <para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para> 
    /// </remarks> 
    /// <returns>The opened <see cref="FileStream"/> object.</returns> 
    public static FileStream GetSecureDeleteOnCloseTempFileStream() 
    {  
     return GetSecureDeleteOnCloseTempFileStream(defaultBufferSize, FileOptions.DeleteOnClose);  
    } 

    /// <summary> 
    /// Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream with the specified buffer size. 
    /// </summary> 
    /// <remarks> 
    /// <para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para> 
    /// <para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para> 
    /// <para>The file is created as a zero-byte file in the system's temporary folder.</para> 
    /// <para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para> 
    /// <para>The file sharing is set to none.</para> 
    /// <para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para> 
    /// <para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para> 
    /// </remarks> 
    /// <param name="bufferSize">A positive <see cref="Int32"/> value greater than 0 indicating the buffer size.</param> 
    /// <returns>The opened <see cref="FileStream"/> object.</returns> 
    public static FileStream GetSecureDeleteOnCloseTempFileStream(int bufferSize) 
    { 
     return GetSecureDeleteOnCloseTempFileStream(bufferSize, FileOptions.DeleteOnClose); 
    } 

    /// <summary> 
    /// Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream with the specified buffer size and file options. 
    /// </summary> 
    /// <remarks> 
    /// <para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para> 
    /// <para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para> 
    /// <para>The file is created as a zero-byte file in the system's temporary folder.</para> 
    /// <para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para> 
    /// <para>The file sharing is set to none.</para> 
    /// <para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para> 
    /// <para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para> 
    /// <para>Use the <paramref name="options"/> parameter to specify additional file options. You can specify <see cref="FileOptions.Encrypted"/> to encrypt the file contents using the current user account. Specify <see cref="FileOptions.Asynchronous"/> to enable overlapped I/O when using asynchronous reads and writes.</para> 
    /// </remarks> 
    /// <param name="bufferSize">A positive <see cref="Int32"/> value greater than 0 indicating the buffer size.</param> 
    /// <param name="options">A <see cref="FileOptions"/> value that specifies additional file options.</param> 
    /// <returns>The opened <see cref="FileStream"/> object.</returns> 
    public static FileStream GetSecureDeleteOnCloseTempFileStream(int bufferSize, FileOptions options) 
    {  
     FileStream fs = GetSecureFileStream(Path.GetTempPath(), bufferSize, options | FileOptions.DeleteOnClose); 

     File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.Temporary); 

     return fs;  
    } 

#endregion 

#region GetSecureTempFileStream 

    public static FileStream GetSecureTempFileStream() 
    {  
     return GetSecureTempFileStream(defaultBufferSize, FileOptions.None);  
    } 

    public static FileStream GetSecureTempFileStream(int bufferSize) 
    { 
     return GetSecureTempFileStream(bufferSize, FileOptions.None); 
    } 

    public static FileStream GetSecureTempFileStream(int bufferSize, FileOptions options) 
    { 
     FileStream fs = GetSecureFileStream(Path.GetTempPath(), bufferSize, options); 

     File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.NotContentIndexed | FileAttributes.Temporary); 

     return fs; 
    } 

    #endregion 

#region GetSecureTempFileName 

    public static string GetSecureTempFileName() 
    {  
     return GetSecureTempFileName(false);  
    } 

    public static string GetSecureTempFileName(bool encrypted) 
    {  
     using (FileStream fs = GetSecureFileStream(Path.GetTempPath(), defaultBufferSize, encrypted ? FileOptions.Encrypted : FileOptions.None)) 
     {  
      File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.NotContentIndexed | FileAttributes.Temporary); 

      return fs.Name;  
     } 

    } 

#endregion 

#region GetSecureFileName 

    public static string GetSecureFileName(string path) 
    {  
     return GetSecureFileName(path, false);  
    } 

    public static string GetSecureFileName(string path, bool encrypted) 
    {  
     using (FileStream fs = GetSecureFileStream(path, defaultBufferSize, encrypted ? FileOptions.Encrypted : FileOptions.None)) 
     {  
      return fs.Name;  
     }  
    } 

#endregion 

#region GetSecureFileStream 

    public static FileStream GetSecureFileStream(string path) 
    {  
     return GetSecureFileStream(path, defaultBufferSize, FileOptions.None);  
    } 

    public static FileStream GetSecureFileStream(string path, int bufferSize) 
    { 
     return GetSecureFileStream(path, bufferSize, FileOptions.None); 
    } 

    public static FileStream GetSecureFileStream(string path, int bufferSize, FileOptions options) 
    {  
     if (path == null) 
      throw new ArgumentNullException("path"); 

     if (bufferSize <= 0) 
      throw new ArgumentOutOfRangeException("bufferSize"); 

     if ((options & ~(FileOptions.Asynchronous | FileOptions.DeleteOnClose | FileOptions.Encrypted | FileOptions.RandomAccess | FileOptions.SequentialScan | FileOptions.WriteThrough)) != FileOptions.None) 
      throw new ArgumentOutOfRangeException("options"); 

     new FileIOPermission(FileIOPermissionAccess.Write, path).Demand(); 

     SecurityIdentifier user = WindowsIdentity.GetCurrent().User; 

     FileSecurity fileSecurity = new FileSecurity(); 

     fileSecurity.AddAccessRule(new FileSystemAccessRule(user, FileSystemRights.FullControl, AccessControlType.Allow)); 

     fileSecurity.SetAccessRuleProtection(true, false); 

     fileSecurity.SetOwner(user); 

     // Attempt to create a unique file three times before giving up. 
     // It is highly improbable that there will ever be a name clash, 
     // therefore we do not check to see if the file first exists. 

     for (int attempt = 0; attempt < 3; attempt++) 
     {  
      try 
      {  
       return new FileStream(Path.Combine(path, Path.GetRandomFileName()), 
             FileMode.CreateNew, FileSystemRights.FullControl, 
             FileShare.None, bufferSize, options, fileSecurity); 
      } 

      catch (IOException) 
      { 
       if (attempt == 2) 
        throw; 
      } 

     } 

     // This code can never be reached. 
     // The compiler thinks otherwise. 
     throw new IOException(); 

    } 

#endregion 

} 

Answer 2

No, esto no es cierto. Básicamente, tu aplicación es responsable de limpiar su propio desorden. Si no lo hace, los archivos temporales se acumularán con el tiempo.

Answer 3

Basado en los archivos de marzo en mi% tmp%, diría que no.

Re por qué se llaman temporales, porque ese es su uso esperado. No son archivos del sistema; no son archivos de aplicación, y no son documentos de usuario ... solo existen para permitir que una aplicación realice un procesamiento temporal (tal vez en grandes volúmenes de datos), o con frecuencia para pasar datos a través de IPC a otro proceso. Por lo tanto, realmente son temporales.

Debe intentar eliminar cualquier archivo temporal que cree, fatal "matar" etc a pesar de eso. A menudo utilizo el "uso" para esto - creo una clase contenedora - es decir,

sealed class TempFile : IDisposable { // formatted for space 
    string path; 
    public string Path { 
     get { 
      if(path==null) throw new ObjectDisposedException(GetType().Name); 
      return path; 
     } 
    } 
    public TempFile() : this(System.IO.Path.GetTempFileName()) { } 

    public TempFile(string path) { 
     if (string.IsNullOrEmpty(path)) throw new ArgumentNullException("path"); 
     this.path = path; 
    } 

    private void Dispose(bool disposing) { 
     if (path != null) { 
      try { 
       File.Delete(path); 
      } catch { } // best endeavours... 
      path = null; 
     } 
    } 
    public void Dispose() { 
     GC.SuppressFinalize(this); 
     Dispose(true); 
    } 
    ~TempFile() { 
     Dispose(false); 
    } 
} 

Answer 4

No, radica en la responsabilidad del software (es decir: el promotor) que crea un archivo temporal para disponer de él.

Tenga una mirada en su propia carpeta de archivos temporales de ver lo bien que funciona ;-)

Answer 5

Hay una opción deFileOptions.DeleteOnClose que podría hacer lo que quiera.

Aquí hay un enlace a la página MSDN.

Answer 6

Se llaman temporales porque en la mayoría de los casos, el usuario puede suponer que puede limpiar de forma segura el desorden en los directorios temporales ... Si no, en general, estos archivos están bloqueados de todos modos.

En general, estos archivos deben ser de corta duración: créelos, úselos para cualquier necesidad que tenga, elimínelos en el acto. En el peor de los casos, elimínelos al salir de la aplicación.

En algún momento, no se puede, por ejemplo. un administrador de archivos o un VCS que permite ver un archivo con un editor (o visor de diferencias, etc.), pero se cierra antes del editor (o no puede monitorear el proceso generado ...).

Answer 7

He leído en Internet una gran cantidad de veces que las personas no quieren usar Path.GetTempFileName porque dicen que podría devolver una ya existente archivo, para resolver el problema puede hacer un nombre de archivo basado en un GUID.

Esta función resuelve ese problema: Itera hasta que encuentra un nombre de archivo inexistente con una extensión específica.

VB.net

Public Shared Function GetTempFileName(ByVal extensionWithDot As String) As String 
    Dim tempFileName As String 
    Do 
     tempFileName = System.IO.Path.GetTempFileName 
     If extensionWithDot IsNot Nothing Then 
      tempFileName = tempFileName.Replace(System.IO.Path.GetExtension(tempFileName), extensionWithDot) 
     End If 
    Loop While System.IO.File.Exists(tempFileName) 
    Return tempFileName 
End Function 

C#:

public static string GetTempFileName(string extensionWithDot) 
{ 
    string tempFileName = null; 
    do { 
     tempFileName = System.IO.Path.GetTempFileName; 
     if (extensionWithDot != null) { 
      tempFileName = tempFileName.Replace(System.IO.Path.GetExtension(tempFileName), extensionWithDot); 
     } 
    } while (System.IO.File.Exists(tempFileName)); 
    return tempFileName; 
} 

Nota: Yo uso argumento extensionWithDot porque System.IO.Path.GetExtension regresa con el punto.