tempfile.h

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