Merge branch 'dl/honor-cflags-in-hdr-check'
[git/git.git] / tempfile.h
CommitLineData
1a9d15db
MH
1#ifndef TEMPFILE_H
2#define TEMPFILE_H
3
24d82185 4#include "list.h"
ef3ca954 5#include "strbuf.h"
24d82185 6
1a9d15db
MH
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 *
1a9d15db 21 * * Attempts to create a temporary file by calling
076aa2cb
JK
22 * `create_tempfile()`. The resources used for the temporary file are
23 * managed by the tempfile API.
1a9d15db
MH
24 *
25 * * Writes new content to the file by either:
26 *
076aa2cb 27 * * writing to the `tempfile->fd` file descriptor
1a9d15db
MH
28 *
29 * * calling `fdopen_tempfile()` to get a `FILE` pointer for the
30 * open file and writing to the file using stdio.
31 *
076aa2cb 32 * Note that the file descriptor created by create_tempfile()
05d1ed61
BW
33 * is marked O_CLOEXEC, so the new contents must be written by
34 * the current process, not any spawned one.
35 *
1a9d15db
MH
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
49bd0fc2 46 * temporary file by calling `close_tempfile_gently()`, and later call
1a9d15db
MH
47 * `delete_tempfile()` or `rename_tempfile()`.
48 *
422a21c6 49 * After the temporary file is renamed or deleted, the `tempfile`
076aa2cb 50 * object is no longer valid and should not be reused.
1a9d15db
MH
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
49bd0fc2 57 * `close_tempfile_gently()`. You should never call `close(2)` or `fclose(3)`
1a9d15db
MH
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 *
076aa2cb
JK
69 * `create_tempfile()` returns an allocated tempfile on success or NULL
70 * on failure. On errors, `errno` describes the reason for failure.
1a9d15db 71 *
5de134ca
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.
1a9d15db
MH
76 */
77
78struct tempfile {
24d82185 79 volatile struct volatile_list_head list;
1a9d15db
MH
80 volatile sig_atomic_t active;
81 volatile int fd;
82 FILE *volatile fp;
83 volatile pid_t owner;
1a9d15db
MH
84 struct strbuf filename;
85};
86
87/*
88 * Attempt to create a temporary file at the specified `path`. Return
076aa2cb
JK
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.
1a9d15db 91 */
55454427 92struct tempfile *create_tempfile(const char *path);
1a9d15db 93
99397152
MH
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 */
55454427 100struct tempfile *register_tempfile(const char *path);
99397152 101
354ab112
MH
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 *
076aa2cb
JK
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).
354ab112
MH
136 */
137
138/* See "mks_tempfile functions" above. */
55454427 139struct tempfile *mks_tempfile_sm(const char *filename_template,
ad6dad09 140 int suffixlen, int mode);
354ab112
MH
141
142/* See "mks_tempfile functions" above. */
ea8ace4a 143static inline struct tempfile *mks_tempfile_s(const char *filename_template,
076aa2cb 144 int suffixlen)
354ab112 145{
ea8ace4a 146 return mks_tempfile_sm(filename_template, suffixlen, 0600);
354ab112
MH
147}
148
149/* See "mks_tempfile functions" above. */
ea8ace4a 150static inline struct tempfile *mks_tempfile_m(const char *filename_template, int mode)
354ab112 151{
ea8ace4a 152 return mks_tempfile_sm(filename_template, 0, mode);
354ab112
MH
153}
154
155/* See "mks_tempfile functions" above. */
ea8ace4a 156static inline struct tempfile *mks_tempfile(const char *filename_template)
354ab112 157{
ea8ace4a 158 return mks_tempfile_sm(filename_template, 0, 0600);
354ab112
MH
159}
160
161/* See "mks_tempfile functions" above. */
55454427 162struct tempfile *mks_tempfile_tsm(const char *filename_template,
ad6dad09 163 int suffixlen, int mode);
354ab112
MH
164
165/* See "mks_tempfile functions" above. */
ea8ace4a 166static inline struct tempfile *mks_tempfile_ts(const char *filename_template,
076aa2cb 167 int suffixlen)
354ab112 168{
ea8ace4a 169 return mks_tempfile_tsm(filename_template, suffixlen, 0600);
354ab112
MH
170}
171
172/* See "mks_tempfile functions" above. */
ea8ace4a 173static inline struct tempfile *mks_tempfile_tm(const char *filename_template, int mode)
354ab112 174{
ea8ace4a 175 return mks_tempfile_tsm(filename_template, 0, mode);
354ab112
MH
176}
177
178/* See "mks_tempfile functions" above. */
ea8ace4a 179static inline struct tempfile *mks_tempfile_t(const char *filename_template)
354ab112 180{
ea8ace4a 181 return mks_tempfile_tsm(filename_template, 0, 0600);
354ab112
MH
182}
183
184/* See "mks_tempfile functions" above. */
55454427 185struct tempfile *xmks_tempfile_m(const char *filename_template, int mode);
354ab112
MH
186
187/* See "mks_tempfile functions" above. */
ea8ace4a 188static inline struct tempfile *xmks_tempfile(const char *filename_template)
354ab112 189{
ea8ace4a 190 return xmks_tempfile_m(filename_template, 0600);
354ab112
MH
191}
192
1a9d15db
MH
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
49bd0fc2 196 * stream is closed automatically when `close_tempfile_gently()` is called or
1a9d15db
MH
197 * when the file is deleted or renamed.
198 */
55454427 199FILE *fdopen_tempfile(struct tempfile *tempfile, const char *mode);
1a9d15db
MH
200
201static inline int is_tempfile_active(struct tempfile *tempfile)
202{
f5b4dc76 203 return tempfile && tempfile->active;
1a9d15db
MH
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 */
55454427 210const char *get_tempfile_path(struct tempfile *tempfile);
1a9d15db 211
55454427
DL
212int get_tempfile_fd(struct tempfile *tempfile);
213FILE *get_tempfile_fp(struct tempfile *tempfile);
1a9d15db
MH
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)`,
49bd0fc2
JK
219 * return a negative value. Usually `delete_tempfile()` or `rename_tempfile()`
220 * should eventually be called regardless of whether `close_tempfile_gently()`
221 * succeeds.
1a9d15db 222 */
55454427 223int close_tempfile_gently(struct tempfile *tempfile);
1a9d15db
MH
224
225/*
226 * Re-open a temporary file that has been closed using
49bd0fc2 227 * `close_tempfile_gently()` but not yet deleted or renamed. This can be used
1a9d15db
MH
228 * to implement a sequence of operations like the following:
229 *
230 * * Create temporary file.
231 *
49bd0fc2 232 * * Write new contents to file, then `close_tempfile_gently()` to cause the
1a9d15db
MH
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 *
6c003d6f
JK
239 * * `reopen_tempfile()` to reopen the temporary file, truncating the existing
240 * contents. Write out the new contents.
1a9d15db
MH
241 *
242 * * `rename_tempfile()` to move the file to its permanent location.
243 */
55454427 244int reopen_tempfile(struct tempfile *tempfile);
1a9d15db
MH
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 */
55454427 252void delete_tempfile(struct tempfile **tempfile_p);
1a9d15db
MH
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 */
55454427 263int rename_tempfile(struct tempfile **tempfile_p, const char *path);
1a9d15db
MH
264
265#endif /* TEMPFILE_H */