summaryrefslogtreecommitdiffstats
path: root/tempfile.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 14:47:53 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 14:47:53 +0000
commitc8bae7493d2f2910b57f13ded012e86bdcfb0532 (patch)
tree24e09d9f84dec336720cf393e156089ca2835791 /tempfile.h
parentInitial commit. (diff)
downloadgit-c8bae7493d2f2910b57f13ded012e86bdcfb0532.tar.xz
git-c8bae7493d2f2910b57f13ded012e86bdcfb0532.zip
Adding upstream version 1:2.39.2.upstream/1%2.39.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--tempfile.h285
1 files changed, 285 insertions, 0 deletions
diff --git a/tempfile.h b/tempfile.h
new file mode 100644
index 0000000..d0413af
--- /dev/null
+++ b/tempfile.h
@@ -0,0 +1,285 @@
+#ifndef TEMPFILE_H
+#define TEMPFILE_H
+
+#include "list.h"
+#include "strbuf.h"
+
+/*
+ * Handle temporary files.
+ *
+ * The tempfile API allows temporary files to be created, deleted, and
+ * atomically renamed. Temporary files that are still active when the
+ * program ends are cleaned up automatically. Lockfiles (see
+ * "lockfile.h") are built on top of this API.
+ *
+ *
+ * Calling sequence
+ * ----------------
+ *
+ * The caller:
+ *
+ * * Attempts to create a temporary file by calling
+ * `create_tempfile()`. The resources used for the temporary file are
+ * managed by the tempfile API.
+ *
+ * * Writes new content to the file by either:
+ *
+ * * writing to the `tempfile->fd` file descriptor
+ *
+ * * calling `fdopen_tempfile()` to get a `FILE` pointer for the
+ * open file and writing to the file using stdio.
+ *
+ * Note that the file descriptor created by create_tempfile()
+ * is marked O_CLOEXEC, so the new contents must be written by
+ * the current process, not any spawned one.
+ *
+ * When finished writing, the caller can:
+ *
+ * * Close the file descriptor and remove the temporary file by
+ * calling `delete_tempfile()`.
+ *
+ * * Close the temporary file and rename it atomically to a specified
+ * filename by calling `rename_tempfile()`. This relinquishes
+ * control of the file.
+ *
+ * * Close the file descriptor without removing or renaming the
+ * temporary file by calling `close_tempfile_gently()`, and later call
+ * `delete_tempfile()` or `rename_tempfile()`.
+ *
+ * After the temporary file is renamed or deleted, the `tempfile`
+ * object is no longer valid and should not be reused.
+ *
+ * If the program exits before `rename_tempfile()` or
+ * `delete_tempfile()` is called, an `atexit(3)` handler will close
+ * and remove the temporary file.
+ *
+ * If you need to close the file descriptor yourself, do so by calling
+ * `close_tempfile_gently()`. You should never call `close(2)` or `fclose(3)`
+ * yourself, otherwise the `struct tempfile` structure would still
+ * think that the file descriptor needs to be closed, and a later
+ * cleanup would result in duplicate calls to `close(2)`. Worse yet,
+ * if you close and then later open another file descriptor for a
+ * completely different purpose, then the unrelated file descriptor
+ * might get closed.
+ *
+ *
+ * Error handling
+ * --------------
+ *
+ * `create_tempfile()` returns an allocated tempfile on success or NULL
+ * on failure. On errors, `errno` describes the reason for failure.
+ *
+ * `rename_tempfile()` and `close_tempfile_gently()` return 0 on success.
+ * On failure they set `errno` appropriately and return -1.
+ * `delete_tempfile()` and `rename` (but not `close`) do their best to
+ * delete the temporary file before returning.
+ */
+
+struct tempfile {
+ volatile struct volatile_list_head list;
+ volatile int fd;
+ FILE *volatile fp;
+ volatile pid_t owner;
+ struct strbuf filename;
+ char *directory;
+};
+
+/*
+ * Attempt to create a temporary file at the specified `path`. Return
+ * a tempfile (whose "fd" member can be used for writing to it), or
+ * NULL on error. It is an error if a file already exists at that path.
+ * Note that `mode` will be further modified by the umask, and possibly
+ * `core.sharedRepository`, so it is not guaranteed to have the given
+ * mode.
+ */
+struct tempfile *create_tempfile_mode(const char *path, int mode);
+
+static inline struct tempfile *create_tempfile(const char *path)
+{
+ return create_tempfile_mode(path, 0666);
+}
+
+/*
+ * Register an existing file as a tempfile, meaning that it will be
+ * deleted when the program exits. The tempfile is considered closed,
+ * but it can be worked with like any other closed tempfile (for
+ * example, it can be opened using reopen_tempfile()).
+ */
+struct tempfile *register_tempfile(const char *path);
+
+
+/*
+ * mks_tempfile functions
+ *
+ * The following functions attempt to create and open temporary files
+ * with names derived automatically from a template, in the manner of
+ * mkstemps(), and arrange for them to be deleted if the program ends
+ * before they are deleted explicitly. There is a whole family of such
+ * functions, named according to the following pattern:
+ *
+ * x?mks_tempfile_t?s?m?()
+ *
+ * The optional letters have the following meanings:
+ *
+ * x - die if the temporary file cannot be created.
+ *
+ * t - create the temporary file under $TMPDIR (as opposed to
+ * relative to the current directory). When these variants are
+ * used, template should be the pattern for the filename alone,
+ * without a path.
+ *
+ * s - template includes a suffix that is suffixlen characters long.
+ *
+ * m - the temporary file should be created with the specified mode
+ * (otherwise, the mode is set to 0600).
+ *
+ * None of these functions modify template. If the caller wants to
+ * know the (absolute) path of the file that was created, it can be
+ * read from tempfile->filename.
+ *
+ * On success, the functions return a tempfile whose "fd" member is open
+ * for writing the temporary file. On errors, they return NULL and set
+ * errno appropriately (except for the "x" variants, which die() on
+ * errors).
+ */
+
+/* See "mks_tempfile functions" above. */
+struct tempfile *mks_tempfile_sm(const char *filename_template,
+ int suffixlen, int mode);
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile_s(const char *filename_template,
+ int suffixlen)
+{
+ return mks_tempfile_sm(filename_template, suffixlen, 0600);
+}
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile_m(const char *filename_template, int mode)
+{
+ return mks_tempfile_sm(filename_template, 0, mode);
+}
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile(const char *filename_template)
+{
+ return mks_tempfile_sm(filename_template, 0, 0600);
+}
+
+/* See "mks_tempfile functions" above. */
+struct tempfile *mks_tempfile_tsm(const char *filename_template,
+ int suffixlen, int mode);
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile_ts(const char *filename_template,
+ int suffixlen)
+{
+ return mks_tempfile_tsm(filename_template, suffixlen, 0600);
+}
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile_tm(const char *filename_template, int mode)
+{
+ return mks_tempfile_tsm(filename_template, 0, mode);
+}
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *mks_tempfile_t(const char *filename_template)
+{
+ return mks_tempfile_tsm(filename_template, 0, 0600);
+}
+
+/* See "mks_tempfile functions" above. */
+struct tempfile *xmks_tempfile_m(const char *filename_template, int mode);
+
+/* See "mks_tempfile functions" above. */
+static inline struct tempfile *xmks_tempfile(const char *filename_template)
+{
+ return xmks_tempfile_m(filename_template, 0600);
+}
+
+/*
+ * Attempt to create a temporary directory in $TMPDIR and to create and
+ * open a file in that new directory. Derive the directory name from the
+ * template in the manner of mkdtemp(). Arrange for directory and file
+ * to be deleted if the program exits before they are deleted
+ * explicitly. On success return a tempfile whose "filename" member
+ * contains the full path of the file and its "fd" member is open for
+ * writing the file. On error return NULL and set errno appropriately.
+ */
+struct tempfile *mks_tempfile_dt(const char *directory_template,
+ const char *filename);
+
+/*
+ * Associate a stdio stream with the temporary file (which must still
+ * be open). Return `NULL` (*without* deleting the file) on error. The
+ * stream is closed automatically when `close_tempfile_gently()` is called or
+ * when the file is deleted or renamed.
+ */
+FILE *fdopen_tempfile(struct tempfile *tempfile, const char *mode);
+
+static inline int is_tempfile_active(struct tempfile *tempfile)
+{
+ return !!tempfile;
+}
+
+/*
+ * Return the path of the lockfile. The return value is a pointer to a
+ * field within the lock_file object and should not be freed.
+ */
+const char *get_tempfile_path(struct tempfile *tempfile);
+
+int get_tempfile_fd(struct tempfile *tempfile);
+FILE *get_tempfile_fp(struct tempfile *tempfile);
+
+/*
+ * If the temporary file is still open, close it (and the file pointer
+ * too, if it has been opened using `fdopen_tempfile()`) without
+ * deleting the file. Return 0 upon success. On failure to `close(2)`,
+ * return a negative value. Usually `delete_tempfile()` or `rename_tempfile()`
+ * should eventually be called regardless of whether `close_tempfile_gently()`
+ * succeeds.
+ */
+int close_tempfile_gently(struct tempfile *tempfile);
+
+/*
+ * Re-open a temporary file that has been closed using
+ * `close_tempfile_gently()` but not yet deleted or renamed. This can be used
+ * to implement a sequence of operations like the following:
+ *
+ * * Create temporary file.
+ *
+ * * Write new contents to file, then `close_tempfile_gently()` to cause the
+ * contents to be written to disk.
+ *
+ * * Pass the name of the temporary file to another program to allow
+ * it (and nobody else) to inspect or even modify the file's
+ * contents.
+ *
+ * * `reopen_tempfile()` to reopen the temporary file, truncating the existing
+ * contents. Write out the new contents.
+ *
+ * * `rename_tempfile()` to move the file to its permanent location.
+ */
+int reopen_tempfile(struct tempfile *tempfile);
+
+/*
+ * Close the file descriptor and/or file pointer and remove the
+ * temporary file associated with `tempfile`. It is a NOOP to call
+ * `delete_tempfile()` for a `tempfile` object that has already been
+ * deleted or renamed.
+ */
+void delete_tempfile(struct tempfile **tempfile_p);
+
+/*
+ * Close the file descriptor and/or file pointer if they are still
+ * open, and atomically rename the temporary file to `path`. `path`
+ * must be on the same filesystem as the lock file. Return 0 on
+ * success. On failure, delete the temporary file and return -1, with
+ * `errno` set to the value from the failing call to `close(2)` or
+ * `rename(2)`. It is a bug to call `rename_tempfile()` for a
+ * `tempfile` object that is not currently active.
+ */
+int rename_tempfile(struct tempfile **tempfile_p, const char *path);
+
+#endif /* TEMPFILE_H */