ioutil.TempFile and umask

In my Go application instead of writing to a file directly I would like to write to a temporary that is renamed into the final file when everything is done. This is to avoid leaving partially written content in the file if the application crashes.

Currently I use ioutil.TempFile, but the issue is that it creates the file with the 0600 permission, not 0666. Thus with typical umask values one gets the 0600 permission, not expected 0644 or 0660. This is not a problem is the destination file already exist as I can fix the permission on the temporary to much the existing ones, but if the file does not exist, then I need somehow to deduce the current umask.

I suppose I can just duplicate ioutil.TempFile implementation to pass 0666 into os.OpenFile, but that does not sound nice. So the question is there a better way?

You can use ioutil.TempDir to get the folder where temporary files should be stored an than create the file on your own with the right permissions.

I don't quite grok your problem.

Temporary files must be created with as tight permissions as possible because the whole idea of having them is to provide your application with secure means of temporary storing data which is too big to fit in memory (or to hand the generated file over to another process). (Note that on POSIX systems, where an opened file counts as a live reference to it, it's even customary to immediately remove the file while having it open so that there's no way to modify its data other than writing it from the process which created it.)

So in my opinion you're trying to use a wrong solution to your problem.

So what I do in a case like yours is:

1. Create a file with the same name as old one but with the ".temp" suffix appended.
2. Write data there.
3. Close, rename it over the old one.

If you feel like using a fixed suffix is lame, you can "steal" the implementation of picking a unique non-conflicting file name from ioutil.TempFile(). But IMO this would be overengeneering.

Matching exactly the requirements of the question, that should do:

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"syscall"
)

func getCurrentUmask() int {
	// Get current umask
	currentUmask := syscall.Umask(0)
	// Restore it to previous value
	syscall.Umask(currentUmask)
	// Return the value
	return currentUmask
}

func atomicWriteFile(filename string, data []byte, perm os.FileMode) error {
	reader := bytes.NewBuffer(data)
	dataSize := int64(len(data))

	tmpFile, err := os.CreateTemp(filepath.Dir(filename), ".tmp-"+filepath.Base(filename))
	if err != nil {
		return err
	}

	err = os.Chmod(tmpFile.Name(), perm)
	if err != nil {
		tmpFile.Close()

		return err
	}

	n, err := io.Copy(tmpFile, reader)
	if err == nil && n < dataSize {
		tmpFile.Close()

		return io.ErrShortWrite
	}

	if err != nil {
		tmpFile.Close()

		return err
	}

	if err := tmpFile.Sync(); err != nil {
		tmpFile.Close()

		return err
	}

	if err := tmpFile.Close(); err != nil {
		return err
	}

	return os.Rename(tmpFile.Name(), filename)
}

func main() {
	// Whatever permission you would normally set on your file
	targetPermissionForFile := 0o666

	// How you would normally write a file
	os.WriteFile("using_os.txt", []byte("barbar"), fs.FileMode(targetPermissionForFile))

	// Retrieving the current umask
	mask := getCurrentUmask()

	// Writing it with the atomic method
	atomicWriteFile("using_atomic.txt", []byte("foofoo"), fs.FileMode((^mask)&targetPermissionForFile))

	// Comparing resulting permissions
	info, _ := os.Stat("using_os.txt")
	fmt.Printf("File written using os.WriteFile has permissions: %#o\n", info.Mode())

	info, _ = os.Stat("using_atomic.txt")
	fmt.Printf("File written using atomicWrite has permissions: %#o\n", info.Mode())

}