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 * `rename_tempfile()` and `close_tempfile_gently()` return 0 on success. 72 * On failure they set `errno` appropriately and return -1. 73 * `delete_tempfile()` and `rename` (but not `close`) do their best to 74 * delete the temporary file before returning. 75 */ 76 77struct tempfile { 78volatilestruct volatile_list_head list; 79volatilesig_atomic_t active; 80volatileint fd; 81FILE*volatile fp; 82volatile pid_t owner; 83struct 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 */ 91externstruct 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 */ 99externstruct 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. */ 138externstruct tempfile *mks_tempfile_sm(const char*template, 139int suffixlen,int mode); 140 141/* See "mks_tempfile functions" above. */ 142staticinlinestruct tempfile *mks_tempfile_s(const char*template, 143int suffixlen) 144{ 145returnmks_tempfile_sm(template, suffixlen,0600); 146} 147 148/* See "mks_tempfile functions" above. */ 149staticinlinestruct tempfile *mks_tempfile_m(const char*template,int mode) 150{ 151returnmks_tempfile_sm(template,0, mode); 152} 153 154/* See "mks_tempfile functions" above. */ 155staticinlinestruct tempfile *mks_tempfile(const char*template) 156{ 157returnmks_tempfile_sm(template,0,0600); 158} 159 160/* See "mks_tempfile functions" above. */ 161externstruct tempfile *mks_tempfile_tsm(const char*template, 162int suffixlen,int mode); 163 164/* See "mks_tempfile functions" above. */ 165staticinlinestruct tempfile *mks_tempfile_ts(const char*template, 166int suffixlen) 167{ 168returnmks_tempfile_tsm(template, suffixlen,0600); 169} 170 171/* See "mks_tempfile functions" above. */ 172staticinlinestruct tempfile *mks_tempfile_tm(const char*template,int mode) 173{ 174returnmks_tempfile_tsm(template,0, mode); 175} 176 177/* See "mks_tempfile functions" above. */ 178staticinlinestruct tempfile *mks_tempfile_t(const char*template) 179{ 180returnmks_tempfile_tsm(template,0,0600); 181} 182 183/* See "mks_tempfile functions" above. */ 184externstruct tempfile *xmks_tempfile_m(const char*template,int mode); 185 186/* See "mks_tempfile functions" above. */ 187staticinlinestruct tempfile *xmks_tempfile(const char*template) 188{ 189returnxmks_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 */ 198externFILE*fdopen_tempfile(struct tempfile *tempfile,const char*mode); 199 200staticinlineintis_tempfile_active(struct tempfile *tempfile) 201{ 202return 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 */ 209externconst char*get_tempfile_path(struct tempfile *tempfile); 210 211externintget_tempfile_fd(struct tempfile *tempfile); 212externFILE*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 */ 222externintclose_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 */ 243externintreopen_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 */ 251externvoiddelete_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 */ 262externintrename_tempfile(struct tempfile **tempfile_p,const char*path); 263 264#endif/* TEMPFILE_H */