tempfile.h

   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
  78 struct tempfile {
  79         volatile struct volatile_list_head list;
  80         volatile int fd;
  81         FILE *volatile fp;
  82         volatile pid_t owner;
  83         struct strbuf filename;
  84         char *directory;
  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  * Note that `mode` will be further modified by the umask, and possibly
  92  * `core.sharedRepository`, so it is not guaranteed to have the given
  93  * mode.
  94  */
  95 struct tempfile *create_tempfile_mode(const char *path, int mode);
  96
  97 static inline struct tempfile *create_tempfile(const char *path)
  98 {
  99         return create_tempfile_mode(path, 0666);
 100 }
 101
 102 /*
 103  * Register an existing file as a tempfile, meaning that it will be
 104  * deleted when the program exits. The tempfile is considered closed,
 105  * but it can be worked with like any other closed tempfile (for
 106  * example, it can be opened using reopen_tempfile()).
 107  */
 108 struct tempfile *register_tempfile(const char *path);
 109
 110
 111 /*
 112  * mks_tempfile functions
 113  *
 114  * The following functions attempt to create and open temporary files
 115  * with names derived automatically from a template, in the manner of
 116  * mkstemps(), and arrange for them to be deleted if the program ends
 117  * before they are deleted explicitly. There is a whole family of such
 118  * functions, named according to the following pattern:
 119  *
 120  *     x?mks_tempfile_t?s?m?()
 121  *
 122  * The optional letters have the following meanings:
 123  *
 124  *   x - die if the temporary file cannot be created.
 125  *
 126  *   t - create the temporary file under $TMPDIR (as opposed to
 127  *       relative to the current directory). When these variants are
 128  *       used, template should be the pattern for the filename alone,
 129  *       without a path.
 130  *
 131  *   s - template includes a suffix that is suffixlen characters long.
 132  *
 133  *   m - the temporary file should be created with the specified mode
 134  *       (otherwise, the mode is set to 0600).
 135  *
 136  * None of these functions modify template. If the caller wants to
 137  * know the (absolute) path of the file that was created, it can be
 138  * read from tempfile->filename.
 139  *
 140  * On success, the functions return a tempfile whose "fd" member is open
 141  * for writing the temporary file. On errors, they return NULL and set
 142  * errno appropriately (except for the "x" variants, which die() on
 143  * errors).
 144  */
 145
 146 /* See "mks_tempfile functions" above. */
 147 struct tempfile *mks_tempfile_sm(const char *filename_template,
 148                                  int suffixlen, int mode);
 149
 150 /* See "mks_tempfile functions" above. */
 151 static inline struct tempfile *mks_tempfile_s(const char *filename_template,
 152                                               int suffixlen)
 153 {
 154         return mks_tempfile_sm(filename_template, suffixlen, 0600);
 155 }
 156
 157 /* See "mks_tempfile functions" above. */
 158 static inline struct tempfile *mks_tempfile_m(const char *filename_template, int mode)
 159 {
 160         return mks_tempfile_sm(filename_template, 0, mode);
 161 }
 162
 163 /* See "mks_tempfile functions" above. */
 164 static inline struct tempfile *mks_tempfile(const char *filename_template)
 165 {
 166         return mks_tempfile_sm(filename_template, 0, 0600);
 167 }
 168
 169 /* See "mks_tempfile functions" above. */
 170 struct tempfile *mks_tempfile_tsm(const char *filename_template,
 171                                   int suffixlen, int mode);
 172
 173 /* See "mks_tempfile functions" above. */
 174 static inline struct tempfile *mks_tempfile_ts(const char *filename_template,
 175                                                int suffixlen)
 176 {
 177         return mks_tempfile_tsm(filename_template, suffixlen, 0600);
 178 }
 179
 180 /* See "mks_tempfile functions" above. */
 181 static inline struct tempfile *mks_tempfile_tm(const char *filename_template, int mode)
 182 {
 183         return mks_tempfile_tsm(filename_template, 0, mode);
 184 }
 185
 186 /* See "mks_tempfile functions" above. */
 187 static inline struct tempfile *mks_tempfile_t(const char *filename_template)
 188 {
 189         return mks_tempfile_tsm(filename_template, 0, 0600);
 190 }
 191
 192 /* See "mks_tempfile functions" above. */
 193 struct tempfile *xmks_tempfile_m(const char *filename_template, int mode);
 194
 195 /* See "mks_tempfile functions" above. */
 196 static inline struct tempfile *xmks_tempfile(const char *filename_template)
 197 {
 198         return xmks_tempfile_m(filename_template, 0600);
 199 }
 200
 201 /*
 202  * Attempt to create a temporary directory in $TMPDIR and to create and
 203  * open a file in that new directory. Derive the directory name from the
 204  * template in the manner of mkdtemp(). Arrange for directory and file
 205  * to be deleted if the program exits before they are deleted
 206  * explicitly. On success return a tempfile whose "filename" member
 207  * contains the full path of the file and its "fd" member is open for
 208  * writing the file. On error return NULL and set errno appropriately.
 209  */
 210 struct tempfile *mks_tempfile_dt(const char *directory_template,
 211                                  const char *filename);
 212
 213 /*
 214  * Associate a stdio stream with the temporary file (which must still
 215  * be open). Return `NULL` (*without* deleting the file) on error. The
 216  * stream is closed automatically when `close_tempfile_gently()` is called or
 217  * when the file is deleted or renamed.
 218  */
 219 FILE *fdopen_tempfile(struct tempfile *tempfile, const char *mode);
 220
 221 static inline int is_tempfile_active(struct tempfile *tempfile)
 222 {
 223         return !!tempfile;
 224 }
 225
 226 /*
 227  * Return the path of the lockfile. The return value is a pointer to a
 228  * field within the lock_file object and should not be freed.
 229  */
 230 const char *get_tempfile_path(struct tempfile *tempfile);
 231
 232 int get_tempfile_fd(struct tempfile *tempfile);
 233 FILE *get_tempfile_fp(struct tempfile *tempfile);
 234
 235 /*
 236  * If the temporary file is still open, close it (and the file pointer
 237  * too, if it has been opened using `fdopen_tempfile()`) without
 238  * deleting the file. Return 0 upon success. On failure to `close(2)`,
 239  * return a negative value. Usually `delete_tempfile()` or `rename_tempfile()`
 240  * should eventually be called regardless of whether `close_tempfile_gently()`
 241  * succeeds.
 242  */
 243 int close_tempfile_gently(struct tempfile *tempfile);
 244
 245 /*
 246  * Re-open a temporary file that has been closed using
 247  * `close_tempfile_gently()` but not yet deleted or renamed. This can be used
 248  * to implement a sequence of operations like the following:
 249  *
 250  * * Create temporary file.
 251  *
 252  * * Write new contents to file, then `close_tempfile_gently()` to cause the
 253  *   contents to be written to disk.
 254  *
 255  * * Pass the name of the temporary file to another program to allow
 256  *   it (and nobody else) to inspect or even modify the file's
 257  *   contents.
 258  *
 259  * * `reopen_tempfile()` to reopen the temporary file, truncating the existing
 260  *   contents. Write out the new contents.
 261  *
 262  * * `rename_tempfile()` to move the file to its permanent location.
 263  */
 264 int reopen_tempfile(struct tempfile *tempfile);
 265
 266 /*
 267  * Close the file descriptor and/or file pointer and remove the
 268  * temporary file associated with `tempfile`. It is a NOOP to call
 269  * `delete_tempfile()` for a `tempfile` object that has already been
 270  * deleted or renamed.
 271  */
 272 int delete_tempfile(struct tempfile **tempfile_p);
 273
 274 /*
 275  * Close the file descriptor and/or file pointer if they are still
 276  * open, and atomically rename the temporary file to `path`. `path`
 277  * must be on the same filesystem as the lock file. Return 0 on
 278  * success. On failure, delete the temporary file and return -1, with
 279  * `errno` set to the value from the failing call to `close(2)` or
 280  * `rename(2)`. It is a bug to call `rename_tempfile()` for a
 281  * `tempfile` object that is not currently active.
 282  */
 283 int rename_tempfile(struct tempfile **tempfile_p, const char *path);
 284
 285 #endif /* TEMPFILE_H */