]>
git.ipfire.org Git - thirdparty/git.git/blob - tempfile.h
8 * Handle temporary files.
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.
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.
25 * * Writes new content to the file by either:
27 * * writing to the `tempfile->fd` file descriptor
29 * * calling `fdopen_tempfile()` to get a `FILE` pointer for the
30 * open file and writing to the file using stdio.
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.
36 * When finished writing, the caller can:
38 * * Close the file descriptor and remove the temporary file by
39 * calling `delete_tempfile()`.
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.
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()`.
49 * After the temporary file is renamed or deleted, the `tempfile`
50 * object is no longer valid and should not be reused.
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.
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
69 * `create_tempfile()` returns an allocated tempfile on success or NULL
70 * on failure. On errors, `errno` describes the reason for failure.
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.
79 volatile struct volatile_list_head list
;
80 volatile sig_atomic_t active
;
84 struct strbuf filename
;
89 * Attempt to create a temporary file at the specified `path`. Return
90 * a tempfile (whose "fd" member can be used for writing to it), or
91 * NULL on error. It is an error if a file already exists at that path.
92 * Note that `mode` will be further modified by the umask, and possibly
93 * `core.sharedRepository`, so it is not guaranteed to have the given
96 struct tempfile
*create_tempfile_mode(const char *path
, int mode
);
98 static inline struct tempfile
*create_tempfile(const char *path
)
100 return create_tempfile_mode(path
, 0666);
104 * Register an existing file as a tempfile, meaning that it will be
105 * deleted when the program exits. The tempfile is considered closed,
106 * but it can be worked with like any other closed tempfile (for
107 * example, it can be opened using reopen_tempfile()).
109 struct tempfile
*register_tempfile(const char *path
);
113 * mks_tempfile functions
115 * The following functions attempt to create and open temporary files
116 * with names derived automatically from a template, in the manner of
117 * mkstemps(), and arrange for them to be deleted if the program ends
118 * before they are deleted explicitly. There is a whole family of such
119 * functions, named according to the following pattern:
121 * x?mks_tempfile_t?s?m?()
123 * The optional letters have the following meanings:
125 * x - die if the temporary file cannot be created.
127 * t - create the temporary file under $TMPDIR (as opposed to
128 * relative to the current directory). When these variants are
129 * used, template should be the pattern for the filename alone,
132 * s - template includes a suffix that is suffixlen characters long.
134 * m - the temporary file should be created with the specified mode
135 * (otherwise, the mode is set to 0600).
137 * None of these functions modify template. If the caller wants to
138 * know the (absolute) path of the file that was created, it can be
139 * read from tempfile->filename.
141 * On success, the functions return a tempfile whose "fd" member is open
142 * for writing the temporary file. On errors, they return NULL and set
143 * errno appropriately (except for the "x" variants, which die() on
147 /* See "mks_tempfile functions" above. */
148 struct tempfile
*mks_tempfile_sm(const char *filename_template
,
149 int suffixlen
, int mode
);
151 /* See "mks_tempfile functions" above. */
152 static inline struct tempfile
*mks_tempfile_s(const char *filename_template
,
155 return mks_tempfile_sm(filename_template
, suffixlen
, 0600);
158 /* See "mks_tempfile functions" above. */
159 static inline struct tempfile
*mks_tempfile_m(const char *filename_template
, int mode
)
161 return mks_tempfile_sm(filename_template
, 0, mode
);
164 /* See "mks_tempfile functions" above. */
165 static inline struct tempfile
*mks_tempfile(const char *filename_template
)
167 return mks_tempfile_sm(filename_template
, 0, 0600);
170 /* See "mks_tempfile functions" above. */
171 struct tempfile
*mks_tempfile_tsm(const char *filename_template
,
172 int suffixlen
, int mode
);
174 /* See "mks_tempfile functions" above. */
175 static inline struct tempfile
*mks_tempfile_ts(const char *filename_template
,
178 return mks_tempfile_tsm(filename_template
, suffixlen
, 0600);
181 /* See "mks_tempfile functions" above. */
182 static inline struct tempfile
*mks_tempfile_tm(const char *filename_template
, int mode
)
184 return mks_tempfile_tsm(filename_template
, 0, mode
);
187 /* See "mks_tempfile functions" above. */
188 static inline struct tempfile
*mks_tempfile_t(const char *filename_template
)
190 return mks_tempfile_tsm(filename_template
, 0, 0600);
193 /* See "mks_tempfile functions" above. */
194 struct tempfile
*xmks_tempfile_m(const char *filename_template
, int mode
);
196 /* See "mks_tempfile functions" above. */
197 static inline struct tempfile
*xmks_tempfile(const char *filename_template
)
199 return xmks_tempfile_m(filename_template
, 0600);
203 * Attempt to create a temporary directory in $TMPDIR and to create and
204 * open a file in that new directory. Derive the directory name from the
205 * template in the manner of mkdtemp(). Arrange for directory and file
206 * to be deleted if the program exits before they are deleted
207 * explicitly. On success return a tempfile whose "filename" member
208 * contains the full path of the file and its "fd" member is open for
209 * writing the file. On error return NULL and set errno appropriately.
211 struct tempfile
*mks_tempfile_dt(const char *directory_template
,
212 const char *filename
);
215 * Associate a stdio stream with the temporary file (which must still
216 * be open). Return `NULL` (*without* deleting the file) on error. The
217 * stream is closed automatically when `close_tempfile_gently()` is called or
218 * when the file is deleted or renamed.
220 FILE *fdopen_tempfile(struct tempfile
*tempfile
, const char *mode
);
222 static inline int is_tempfile_active(struct tempfile
*tempfile
)
224 return tempfile
&& tempfile
->active
;
228 * Return the path of the lockfile. The return value is a pointer to a
229 * field within the lock_file object and should not be freed.
231 const char *get_tempfile_path(struct tempfile
*tempfile
);
233 int get_tempfile_fd(struct tempfile
*tempfile
);
234 FILE *get_tempfile_fp(struct tempfile
*tempfile
);
237 * If the temporary file is still open, close it (and the file pointer
238 * too, if it has been opened using `fdopen_tempfile()`) without
239 * deleting the file. Return 0 upon success. On failure to `close(2)`,
240 * return a negative value. Usually `delete_tempfile()` or `rename_tempfile()`
241 * should eventually be called regardless of whether `close_tempfile_gently()`
244 int close_tempfile_gently(struct tempfile
*tempfile
);
247 * Re-open a temporary file that has been closed using
248 * `close_tempfile_gently()` but not yet deleted or renamed. This can be used
249 * to implement a sequence of operations like the following:
251 * * Create temporary file.
253 * * Write new contents to file, then `close_tempfile_gently()` to cause the
254 * contents to be written to disk.
256 * * Pass the name of the temporary file to another program to allow
257 * it (and nobody else) to inspect or even modify the file's
260 * * `reopen_tempfile()` to reopen the temporary file, truncating the existing
261 * contents. Write out the new contents.
263 * * `rename_tempfile()` to move the file to its permanent location.
265 int reopen_tempfile(struct tempfile
*tempfile
);
268 * Close the file descriptor and/or file pointer and remove the
269 * temporary file associated with `tempfile`. It is a NOOP to call
270 * `delete_tempfile()` for a `tempfile` object that has already been
271 * deleted or renamed.
273 void delete_tempfile(struct tempfile
**tempfile_p
);
276 * Close the file descriptor and/or file pointer if they are still
277 * open, and atomically rename the temporary file to `path`. `path`
278 * must be on the same filesystem as the lock file. Return 0 on
279 * success. On failure, delete the temporary file and return -1, with
280 * `errno` set to the value from the failing call to `close(2)` or
281 * `rename(2)`. It is a bug to call `rename_tempfile()` for a
282 * `tempfile` object that is not currently active.
284 int rename_tempfile(struct tempfile
**tempfile_p
, const char *path
);
286 #endif /* TEMPFILE_H */