Secure temporary file: Difference between revisions

This example creates a temporary file, writes to the file, then reads from the file.

 

 

procedure Temp_File is

Get_Line(File => Temp, Item => Contents, Last => Length);

Put_Line(Contents(1..Length));

 

{{works with|BBC BASIC for Windows}}

The file is automatically deleted when closed.

IF file% = 0 ERROR 100, "Failed to open temp file"

PRINT #file%, "Hello world!"

IF hfile% = INVALID_HANDLE_VALUE THEN = 0

@hfile%(chan%) = hfile%

'''Output:'''

<pre>

Hello world!

</pre>

 

=={{header|C}}==

#include <stdio.h>

 

time you open it. */

return 0;

 

The following {{works with|POSIX}}

#include <stdio.h>

 

close(fd);

return 0;

 

=={{header|C sharp|C#}}==

 

using System.IO;

 

 

=={{header|Clojure}}==

It is good practice to explicitly delete temp files immediately once they've been used.

; insert logic here that would use temp-file

 

=={{header|D}}==

{{works with|Tango}}

import tango.io.TempFile, tango.io.Stdout ;

 

 

// both can only be accessed by the current user (the program?).

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.IOUtils}}

program Secure_temporary_file;

 

writeln(FileName);

Readln;

 

=={{header|Emacs Lisp}}==

<code>make-temp-file</code> creates a new empty temporary file, with perms "0700" so read-write to the current user only.

 

 

=={{header|Fortran}}==

Other attributes might be specified depending on the intended usage, but note that no file name is given. When the file is closed, its storage vanishes back to the file system.

 

=={{header|Go}}==

Use <code>[https://golang.org/pkg/io/ioutil/#TempFile ioutil.TempFile]</code>

 

import (

// The defer statements above will close and remove the

// temporary file here (or on any return of this function).

{{out}}

<pre>

 

=={{header|Groovy}}==

 

// There is no requirement in the instructions to delete the file.

//file.deleteOnExit()

 

 

Output:

 

=={{header|Haskell}}==

 

main = do (pathOfTempFile, h) <- openTempFile "." "prefix.suffix" -- first argument is path to directory where you want to put it

-- do stuff with it here; "h" is the Handle to the opened file

 

=={{header|HicEst}}==

! A scratch file is automatically deleted upon process termination.

 

OPEN( FIle='DenyForOthers', DenyREAdWRIte, IOStat=ErrNr)

WRITE(FIle='DenyForOthers') "something"

 

=={{header|Icon}} and {{header|Unicon}}==

A posix-based solution that works in both languages:

 

write("Creating: ",fName := !open("mktemp","rp"))

write(f := open(fName,"w"),"Hello, world")

close(f)

 

=={{header|Java}}==

 

import java.io.IOException;

 

}

}

 

=={{header|Julia}}==

{{works with|Linux}} On Unix systems, Julia calls <code>mkstemp</code> to securely open a temporary file. This is likely multi-thread safe, check your system documentation for verification. This code should also work on Windows, but I've not verified that.

msg = "Rosetta Code, Secure temporary file, implemented with Julia."

 

close(tio)

println("\"", msg, "\" written to ", fname)

Files written to <code>\tmp</code> persist for the login session, and are thus truly temporary. If the environment variable <code>TMPDIR</code> is set, the temporary file is created in this directory. In this case, the file may not be properly temporary.

ENV["TMPDIR"] = pwd()

(fname, tio) = mktemp()

close(tio)

println("\"", msg, "\" written to ", fname)

 

{{out}}

 

=={{header|Kotlin}}==

 

{{out}}

<pre>

</pre>

 

=={{header|Lua}}==

 

-- do some file operations

 

 

=={{header|M2000 Interpreter}}==

tmp files automatic deleted when Environment end (per running environment)

 

Module Checkit {

\\ we get a tempname$ choosed from Windows

Checkit

 

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|Nanoquery}}==

 

def guaranteedTempFile()

// return the file reference

return $tempfile

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

end

return

 

=={{header|Nim}}==

{{Works with|Nim|1.6.0}}

 

let (file, path) = createTempFile(prefix = "", suffix = "")

for line in path.lines:

echo line

{{out}}

<pre>/tmp/th7lDdkH created.

 

=={{header|OCaml}}==

 

=={{header|Octave}}==

 

Octave has several related functions

filename = tmpnam (...); % generates temporary file name, but does not open file

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

{{libheader|SysUtils}}

 

uses

writeln (tempFile, 5);

close (tempFile);

 

=={{header|Perl}}==

function interface:

$fh = tempfile();

($fh2, $filename) = tempfile(); # this file stays around by default

print "$filename\n";

close $fh;

 

object-oriented interface:

$fh = new File::Temp;

print $fh->filename, "\n";

 

=={{header|Phix}}==

The temp_file() function (see builtins/pfile.e) can be used for this:

{{out}}

<pre>

 

=={{header|PHP}}==

// do stuff with $fh

fclose($fh);

$filename = tempnam('/tmp', 'prefix');

echo "$filename\n";

 

=={{header|PicoLisp}}==

they are (e.g. because such a file name is passed to a child process), explicit

locks with the 'ctl' functions are possible.

-> 123

 

(let N (read) # Atomic increment

(out F (println (inc N))) ) ) ) )

 

=={{header|PowerShell}}==

$tempFile = [System.IO.Path]::GetTempFileName()

Set-Content -Path $tempFile -Value "FileName = $tempFile"

Get-Content -Path $tempFile

Remove-Item -Path $tempFile

{{Out}}

<pre>

 

=={{header|PureBasic}}==

Protected a, Result$

 

CloseFile(File)

EndIf

 

=={{header|Python}}==

 

 

>>> invisible = tempfile.TemporaryFile()

>>> invisible.name

'/tmp/tmpZNfc_s'

>>> visible.close()

 

 

 

 

try:

# use the path or the file descriptor

finally:

 

=={{header|Racket}}==

 

#lang racket

(make-temporary-file)

 

=={{header|Raku}}==

 

Almost verbatim from the synopsis:

 

# Generate a temp file in a temp dir

 

# specify a prefix, a suffix, or both for the filename

 

=={{header|REXX}}==

REXX uses the underlying OS to create and delete the file.

parse arg tFID # . /*obtain optional argument from the CL.*/

if tFID=='' | tFID=="," then tFID= 'TEMP.FILE' /*Not specified? Then use the default.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

use tempfile::tempfile;

 

println!("{:?}", fh);

{{out}}

<pre>

 

=={{header|Scala}}==

 

def writeStringToFile(file: File, data: String, appending: Boolean = false) =

} catch {

case e: IOException => println(s"Running Example failed: ${e.getMessage}")

 

=={{header|Sidef}}==

var fh = tmpfile.new(UNLINK => 0);

say fh.filename;

fh.print("Hello, World!\n");

 

=={{header|Standard ML}}==

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

Will store the name of the file in the variable <code>filenameVar</code> and an open read-write channel on the file in the variable <code>chan</code>.

Note that because we're asking for the filename in the script, Tcl does not automatically clean the file. (There are cases where auto-cleaning would be really unwanted.) If we hadn't asked for it, the file would be automatically deleted (at a time that depends on platform constraints).

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

tmpfile="test.txt"

FILE $tmpfile = text

- tmpfile "test.txt" can only be accessed by one user an will be deleted upon programm termination

 

=={{header|UNIX Shell}}==

thereunder.

 

TRY=0

while :; do

cd "$MYTMP" || {

echo "Temporary directory failure on $MYTMP" >&2

 

Note that the shell special variable $$ (the PID of the currently ''exec()''-ed shell) is unique at any given

{{libheader|Wren-ioutil}}

{{libheader|Wren-fmt}}

 

var rand = Random.new()

System.print(File.read(tmp))

File.delete(tmp)

 

{{out}}