tempfile.hon commit Merge branch 'rs/get-tagged-oid' (cf861cd)
   1#ifndef TEMPFILE_H
   2#define TEMPFILE_H
   3
   4#include "list.h"
   5#include "strbuf.h"
   6
   7/*
   8 * Handle temporary files.
   9 *
  10 * The tempfile API allows temporary files to be created, deleted, and
  11 * atomically renamed. Temporary files that are still active when the
  12 * program ends are cleaned up automatically. Lockfiles (see
  13 * "lockfile.h") are built on top of this API.
  14 *
  15 *
  16 * Calling sequence
  17 * ----------------
  18 *
  19 * The caller:
  20 *
  21 * * Attempts to create a temporary file by calling
  22 *   `create_tempfile()`. The resources used for the temporary file are
  23 *   managed by the tempfile API.
  24 *
  25 * * Writes new content to the file by either:
  26 *
  27 *   * writing to the `tempfile->fd` file descriptor
  28 *
  29 *   * calling `fdopen_tempfile()` to get a `FILE` pointer for the
  30 *     open file and writing to the file using stdio.
  31 *
  32 *   Note that the file descriptor created by create_tempfile()
  33 *   is marked O_CLOEXEC, so the new contents must be written by
  34 *   the current process, not any spawned one.
  35 *
  36 * When finished writing, the caller can:
  37 *
  38 * * Close the file descriptor and remove the temporary file by
  39 *   calling `delete_tempfile()`.
  40 *
  41 * * Close the temporary file and rename it atomically to a specified
  42 *   filename by calling `rename_tempfile()`. This relinquishes
  43 *   control of the file.
  44 *
  45 * * Close the file descriptor without removing or renaming the
  46 *   temporary file by calling `close_tempfile_gently()`, and later call
  47 *   `delete_tempfile()` or `rename_tempfile()`.
  48 *
  49 * After the temporary file is renamed or deleted, the `tempfile`
  50 * object is no longer valid and should not be reused.
  51 *
  52 * If the program exits before `rename_tempfile()` or
  53 * `delete_tempfile()` is called, an `atexit(3)` handler will close
  54 * and remove the temporary file.
  55 *
  56 * If you need to close the file descriptor yourself, do so by calling
  57 * `close_tempfile_gently()`. You should never call `close(2)` or `fclose(3)`
  58 * yourself, otherwise the `struct tempfile` structure would still
  59 * think that the file descriptor needs to be closed, and a later
  60 * cleanup would result in duplicate calls to `close(2)`. Worse yet,
  61 * if you close and then later open another file descriptor for a
  62 * completely different purpose, then the unrelated file descriptor
  63 * might get closed.
  64 *
  65 *
  66 * Error handling
  67 * --------------
  68 *
  69 * `create_tempfile()` returns an allocated tempfile on success or NULL
  70 * on failure. On errors, `errno` describes the reason for failure.
  71 *
  72 * `rename_tempfile()` and `close_tempfile_gently()` return 0 on success.
  73 * On failure they set `errno` appropriately and return -1.
  74 * `delete_tempfile()` and `rename` (but not `close`) do their best to
  75 * delete the temporary file before returning.
  76 */
  77
  78struct tempfile {
  79        volatile struct volatile_list_head list;
  80        volatile sig_atomic_t active;
  81        volatile int fd;
  82        FILE *volatile fp;
  83        volatile pid_t owner;
  84        struct strbuf filename;
  85};
  86
  87/*
  88 * Attempt to create a temporary file at the specified `path`. Return
  89 * a tempfile (whose "fd" member can be used for writing to it), or
  90 * NULL on error. It is an error if a file already exists at that path.
  91 */
  92struct tempfile *create_tempfile(const char *path);
  93
  94/*
  95 * Register an existing file as a tempfile, meaning that it will be
  96 * deleted when the program exits. The tempfile is considered closed,
  97 * but it can be worked with like any other closed tempfile (for
  98 * example, it can be opened using reopen_tempfile()).
  99 */
 100struct tempfile *register_tempfile(const char *path);
 101
 102
 103/*
 104 * mks_tempfile functions
 105 *
 106 * The following functions attempt to create and open temporary files
 107 * with names derived automatically from a template, in the manner of
 108 * mkstemps(), and arrange for them to be deleted if the program ends
 109 * before they are deleted explicitly. There is a whole family of such
 110 * functions, named according to the following pattern:
 111 *
 112 *     x?mks_tempfile_t?s?m?()
 113 *
 114 * The optional letters have the following meanings:
 115 *
 116 *   x - die if the temporary file cannot be created.
 117 *
 118 *   t - create the temporary file under $TMPDIR (as opposed to
 119 *       relative to the current directory). When these variants are
 120 *       used, template should be the pattern for the filename alone,
 121 *       without a path.
 122 *
 123 *   s - template includes a suffix that is suffixlen characters long.
 124 *
 125 *   m - the temporary file should be created with the specified mode
 126 *       (otherwise, the mode is set to 0600).
 127 *
 128 * None of these functions modify template. If the caller wants to
 129 * know the (absolute) path of the file that was created, it can be
 130 * read from tempfile->filename.
 131 *
 132 * On success, the functions return a tempfile whose "fd" member is open
 133 * for writing the temporary file. On errors, they return NULL and set
 134 * errno appropriately (except for the "x" variants, which die() on
 135 * errors).
 136 */
 137
 138/* See "mks_tempfile functions" above. */
 139struct tempfile *mks_tempfile_sm(const char *filename_template,
 140                                 int suffixlen, int mode);
 141
 142/* See "mks_tempfile functions" above. */
 143static inline struct tempfile *mks_tempfile_s(const char *filename_template,
 144                                              int suffixlen)
 145{
 146        return mks_tempfile_sm(filename_template, suffixlen, 0600);
 147}
 148
 149/* See "mks_tempfile functions" above. */
 150static inline struct tempfile *mks_tempfile_m(const char *filename_template, int mode)
 151{
 152        return mks_tempfile_sm(filename_template, 0, mode);
 153}
 154
 155/* See "mks_tempfile functions" above. */
 156static inline struct tempfile *mks_tempfile(const char *filename_template)
 157{
 158        return mks_tempfile_sm(filename_template, 0, 0600);
 159}
 160
 161/* See "mks_tempfile functions" above. */
 162struct tempfile *mks_tempfile_tsm(const char *filename_template,
 163                                  int suffixlen, int mode);
 164
 165/* See "mks_tempfile functions" above. */
 166static inline struct tempfile *mks_tempfile_ts(const char *filename_template,
 167                                               int suffixlen)
 168{
 169        return mks_tempfile_tsm(filename_template, suffixlen, 0600);
 170}
 171
 172/* See "mks_tempfile functions" above. */
 173static inline struct tempfile *mks_tempfile_tm(const char *filename_template, int mode)
 174{
 175        return mks_tempfile_tsm(filename_template, 0, mode);
 176}
 177
 178/* See "mks_tempfile functions" above. */
 179static inline struct tempfile *mks_tempfile_t(const char *filename_template)
 180{
 181        return mks_tempfile_tsm(filename_template, 0, 0600);
 182}
 183
 184/* See "mks_tempfile functions" above. */
 185struct tempfile *xmks_tempfile_m(const char *filename_template, int mode);
 186
 187/* See "mks_tempfile functions" above. */
 188static inline struct tempfile *xmks_tempfile(const char *filename_template)
 189{
 190        return xmks_tempfile_m(filename_template, 0600);
 191}
 192
 193/*
 194 * Associate a stdio stream with the temporary file (which must still
 195 * be open). Return `NULL` (*without* deleting the file) on error. The
 196 * stream is closed automatically when `close_tempfile_gently()` is called or
 197 * when the file is deleted or renamed.
 198 */
 199FILE *fdopen_tempfile(struct tempfile *tempfile, const char *mode);
 200
 201static inline int is_tempfile_active(struct tempfile *tempfile)
 202{
 203        return tempfile && tempfile->active;
 204}
 205
 206/*
 207 * Return the path of the lockfile. The return value is a pointer to a
 208 * field within the lock_file object and should not be freed.
 209 */
 210const char *get_tempfile_path(struct tempfile *tempfile);
 211
 212int get_tempfile_fd(struct tempfile *tempfile);
 213FILE *get_tempfile_fp(struct tempfile *tempfile);
 214
 215/*
 216 * If the temporary file is still open, close it (and the file pointer
 217 * too, if it has been opened using `fdopen_tempfile()`) without
 218 * deleting the file. Return 0 upon success. On failure to `close(2)`,
 219 * return a negative value. Usually `delete_tempfile()` or `rename_tempfile()`
 220 * should eventually be called regardless of whether `close_tempfile_gently()`
 221 * succeeds.
 222 */
 223int close_tempfile_gently(struct tempfile *tempfile);
 224
 225/*
 226 * Re-open a temporary file that has been closed using
 227 * `close_tempfile_gently()` but not yet deleted or renamed. This can be used
 228 * to implement a sequence of operations like the following:
 229 *
 230 * * Create temporary file.
 231 *
 232 * * Write new contents to file, then `close_tempfile_gently()` to cause the
 233 *   contents to be written to disk.
 234 *
 235 * * Pass the name of the temporary file to another program to allow
 236 *   it (and nobody else) to inspect or even modify the file's
 237 *   contents.
 238 *
 239 * * `reopen_tempfile()` to reopen the temporary file, truncating the existing
 240 *   contents. Write out the new contents.
 241 *
 242 * * `rename_tempfile()` to move the file to its permanent location.
 243 */
 244int reopen_tempfile(struct tempfile *tempfile);
 245
 246/*
 247 * Close the file descriptor and/or file pointer and remove the
 248 * temporary file associated with `tempfile`. It is a NOOP to call
 249 * `delete_tempfile()` for a `tempfile` object that has already been
 250 * deleted or renamed.
 251 */
 252void delete_tempfile(struct tempfile **tempfile_p);
 253
 254/*
 255 * Close the file descriptor and/or file pointer if they are still
 256 * open, and atomically rename the temporary file to `path`. `path`
 257 * must be on the same filesystem as the lock file. Return 0 on
 258 * success. On failure, delete the temporary file and return -1, with
 259 * `errno` set to the value from the failing call to `close(2)` or
 260 * `rename(2)`. It is a bug to call `rename_tempfile()` for a
 261 * `tempfile` object that is not currently active.
 262 */
 263int rename_tempfile(struct tempfile **tempfile_p, const char *path);
 264
 265#endif /* TEMPFILE_H */