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