t6030: use test_path_is_missing()
[git] / 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 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  */
92 struct 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  */
100 struct 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. */
139 struct tempfile *mks_tempfile_sm(const char *filename_template,
140                                  int suffixlen, int mode);
141
142 /* See "mks_tempfile functions" above. */
143 static 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. */
150 static 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. */
156 static 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. */
162 struct tempfile *mks_tempfile_tsm(const char *filename_template,
163                                   int suffixlen, int mode);
164
165 /* See "mks_tempfile functions" above. */
166 static 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. */
173 static 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. */
179 static 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. */
185 struct tempfile *xmks_tempfile_m(const char *filename_template, int mode);
186
187 /* See "mks_tempfile functions" above. */
188 static 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  */
199 FILE *fdopen_tempfile(struct tempfile *tempfile, const char *mode);
200
201 static 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  */
210 const char *get_tempfile_path(struct tempfile *tempfile);
211
212 int get_tempfile_fd(struct tempfile *tempfile);
213 FILE *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  */
223 int 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  */
244 int 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  */
252 void 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  */
263 int rename_tempfile(struct tempfile **tempfile_p, const char *path);
264
265 #endif /* TEMPFILE_H */