1 /* backupfile.c -- make Emacs style backup file names
2
3 Copyright (C) 1990-2006, 2009-2023 Free Software Foundation, Inc.
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18 /* Written by Paul Eggert and David MacKenzie.
19 Some algorithms adapted from GNU Emacs. */
20
21 #include <config.h>
22
23 #include "backup-internal.h"
24
25 #include <dirent.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <stdckdint.h>
29 #include <stdint.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33
34 #include "attribute.h"
35 #include "basename-lgpl.h"
36 #include "ialloc.h"
37 #include "opendirat.h"
38 #include "renameatu.h"
39
40 #ifndef _D_EXACT_NAMLEN
41 # define _D_EXACT_NAMLEN(dp) strlen ((dp)->d_name)
42 #endif
43
44 #if ! (HAVE_PATHCONF && defined _PC_NAME_MAX)
45 # define pathconf(file, option) (errno = -1)
46 # define fpathconf(fd, option) (errno = -1)
47 #endif
48
49 #ifndef _POSIX_NAME_MAX
50 # define _POSIX_NAME_MAX 14
51 #endif
52
53 #if defined _XOPEN_NAME_MAX
54 # define NAME_MAX_MINIMUM _XOPEN_NAME_MAX
55 #else
56 # define NAME_MAX_MINIMUM _POSIX_NAME_MAX
57 #endif
58
59 #ifndef HAVE_DOS_FILE_NAMES
60 # define HAVE_DOS_FILE_NAMES 0
61 #endif
62 #ifndef HAVE_LONG_FILE_NAMES
63 # define HAVE_LONG_FILE_NAMES 0
64 #endif
65
66 /* ISDIGIT differs from isdigit, as follows:
67 - Its arg may be any int or unsigned int; it need not be an unsigned char
68 or EOF.
69 - It's typically faster.
70 POSIX says that only '0' through '9' are digits. Prefer ISDIGIT to
71 ISDIGIT unless it's important to use the locale's definition
72 of "digit" even when the host does not conform to POSIX. */
73 #define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
74
75 /* The extension added to file names to produce a simple (as opposed
76 to numbered) backup file name. */
77 char const *simple_backup_suffix = NULL;
78
79 /* Set SIMPLE_BACKUP_SUFFIX to S, or to a default specified by the
80 environment if S is null. If S or the environment does not specify
81 a valid backup suffix, use "~". */
82 void
83 set_simple_backup_suffix (char const *s)
84 {
85 if (!s)
86 s = getenv ("SIMPLE_BACKUP_SUFFIX");
87 simple_backup_suffix = s && *s && s == last_component (s) ? s : "~";
88 }
89
90 /* If FILE (which was of length FILELEN before an extension was
91 appended to it) is too long, replace the extension with the single
92 char E. If the result is still too long, remove the char just
93 before E. Return true if the extension was OK already, false
94 if it needed replacement.
95
96 If DIR_FD is nonnegative, it is a file descriptor for FILE's parent.
97 *BASE_MAX is either 0, or the cached result of a previous call for
98 FILE's parent's _PC_NAME_MAX. */
99
100 static bool
101 check_extension (char *file, idx_t filelen, char e,
102 int dir_fd, idx_t *base_max)
103 {
104 char *base = last_component (file);
105 idx_t baselen = base_len (base);
106 idx_t baselen_max = HAVE_LONG_FILE_NAMES ? 255 : NAME_MAX_MINIMUM;
107
108 if (HAVE_DOS_FILE_NAMES || NAME_MAX_MINIMUM < baselen)
109 {
110 /* The new base name is long enough to require a pathconf check. */
111 if (*base_max == 0)
112 {
113 long name_max;
114 if (dir_fd < 0)
115 {
116 /* Temporarily modify the buffer into its parent
117 directory name, invoke pathconf on the directory, and
118 then restore the buffer. */
119 char tmp[sizeof "."];
120 memcpy (tmp, base, sizeof ".");
121 strcpy (base, ".");
122 errno = 0;
123 name_max = pathconf (file, _PC_NAME_MAX);
124 name_max -= !errno;
125 memcpy (base, tmp, sizeof ".");
126 }
127 else
128 {
129 errno = 0;
130 name_max = fpathconf (dir_fd, _PC_NAME_MAX);
131 name_max -= !errno;
132 }
133
134 *base_max = (0 <= name_max && name_max <= SIZE_MAX ? name_max
135 : name_max < -1 ? NAME_MAX_MINIMUM : SIZE_MAX);
136 }
137
138 baselen_max = *base_max;
139 }
140
141 if (HAVE_DOS_FILE_NAMES && baselen_max <= 12)
142 {
143 /* Live within DOS's 8.3 limit. */
144 char *dot = strchr (base, '.');
145 if (!dot)
146 baselen_max = 8;
147 else
148 {
149 char const *second_dot = strchr (dot + 1, '.');
150 baselen_max = (second_dot
151 ? second_dot - base
152 : dot + 1 - base + 3);
153 }
154 }
155
156 if (baselen <= baselen_max)
157 return true;
158 else
159 {
160 baselen = file + filelen - base;
161 if (baselen_max <= baselen)
162 baselen = baselen_max - 1;
163 base[baselen] = e;
164 base[baselen + 1] = '\0';
165 return false;
166 }
167 }
168
169 /* Returned values for NUMBERED_BACKUP. */
170
171 enum numbered_backup_result
172 {
173 /* The new backup name is the same length as an existing backup
174 name, so it's valid for that directory. */
175 BACKUP_IS_SAME_LENGTH,
176
177 /* Some backup names already exist, but the returned name is longer
178 than any of them, and its length should be checked. */
179 BACKUP_IS_LONGER,
180
181 /* There are no existing backup names. The new name's length
182 should be checked. */
183 BACKUP_IS_NEW,
184
185 /* Memory allocation failure. */
186 BACKUP_NOMEM
187 };
188
189 /* Relative to DIR_FD, *BUFFER contains a file name.
190 Store into *BUFFER the next backup name for the named file,
191 with a version number greater than all the
192 existing numbered backups. Reallocate *BUFFER as necessary; its
193 initial allocated size is BUFFER_SIZE, which must be at least 5
194 bytes longer than the file name to make room for the initially
195 appended ".~1~". FILELEN is the length of the original file name.
196 (The original file name is not necessarily null-terminated;
197 FILELEN does not count trailing slashes after a non-slash.)
198 BASE_OFFSET is the offset of the basename in *BUFFER.
199 The returned value indicates what kind of backup was found. If an
200 I/O or other read error occurs, use the highest backup number that
201 was found.
202
203 *DIRPP is the destination directory. If *DIRPP is null, open the
204 destination directory and store the resulting stream into *DIRPP
205 and its file descriptor into *PNEW_FD without closing the stream. */
206
207 static enum numbered_backup_result
208 numbered_backup (int dir_fd, char **buffer, idx_t buffer_size, idx_t filelen,
209 idx_t base_offset, DIR **dirpp, int *pnew_fd)
210 {
211 enum numbered_backup_result result = BACKUP_IS_NEW;
212 DIR *dirp = *dirpp;
213 char *buf = *buffer;
214 idx_t versionlenmax = 1;
215 idx_t baselen = filelen - base_offset;
216
217 if (dirp)
218 rewinddir (dirp);
219 else
220 {
221 /* Temporarily modify the buffer into its parent directory name,
222 open the directory, and then restore the buffer. */
223 char tmp[sizeof "."];
224 char *base = buf + base_offset;
225 memcpy (tmp, base, sizeof ".");
226 strcpy (base, ".");
227 dirp = opendirat (dir_fd, buf, 0, pnew_fd);
228 if (!dirp && errno == ENOMEM)
229 result = BACKUP_NOMEM;
230 memcpy (base, tmp, sizeof ".");
231 strcpy (base + baselen, ".~1~");
232 if (!dirp)
233 return result;
234 *dirpp = dirp;
235 }
236
237 for (struct dirent *dp; (dp = readdir (dirp)) != NULL; )
238 {
239 if (_D_EXACT_NAMLEN (dp) < baselen + 4)
240 continue;
241
242 if (memcmp (buf + base_offset, dp->d_name, baselen + 2) != 0)
243 continue;
244
245 char const *p = dp->d_name + baselen + 2;
246
247 /* Check whether this file has a version number and if so,
248 whether it is larger. Use string operations rather than
249 integer arithmetic, to avoid problems with integer overflow. */
250
251 if (! ('1' <= *p && *p <= '9'))
252 continue;
253 bool all_9s = (*p == '9');
254 idx_t versionlen;
255 for (versionlen = 1; ISDIGIT (p[versionlen]); versionlen++)
256 all_9s &= (p[versionlen] == '9');
257
258 if (! (p[versionlen] == '~' && !p[versionlen + 1]
259 && (versionlenmax < versionlen
260 || (versionlenmax == versionlen
261 && memcmp (buf + filelen + 2, p, versionlen) <= 0))))
262 continue;
263
264 /* This entry has the largest version number seen so far.
265 Append this highest numbered extension to the file name,
266 prepending '0' to the number if it is all 9s. */
267
268 versionlenmax = all_9s + versionlen;
269 result = (all_9s ? BACKUP_IS_LONGER : BACKUP_IS_SAME_LENGTH);
270 idx_t new_buffer_size = filelen + 2 + versionlenmax + 2;
271 if (buffer_size < new_buffer_size)
272 {
273 idx_t grown;
274 if (! ckd_add (&grown, new_buffer_size, new_buffer_size >> 1))
275 new_buffer_size = grown;
276 char *new_buf = irealloc (buf, new_buffer_size);
277 if (!new_buf)
278 {
279 *buffer = buf;
280 return BACKUP_NOMEM;
281 }
282 buf = new_buf;
283 buffer_size = new_buffer_size;
284 }
285 char *q = buf + filelen;
286 *q++ = '.';
287 *q++ = '~';
288 *q = '0';
289 q += all_9s;
290 memcpy (q, p, versionlen + 2);
291
292 /* Add 1 to the version number. */
293
294 q += versionlen;
295 while (*--q == '9')
296 *q = '0';
297 ++*q;
298 }
299
300 *buffer = buf;
301 return result;
302 }
303
304 /* Relative to DIR_FD, return the name of the new backup file for the
305 existing file FILE, allocated with malloc.
306 If RENAME, also rename FILE to the new name.
307 On failure, return NULL and set errno.
308 Do not call this function if backup_type == no_backups. */
309
310 char *
311 backupfile_internal (int dir_fd, char const *file,
312 enum backup_type backup_type, bool rename)
313 {
314 idx_t base_offset = last_component (file) - file;
315 idx_t filelen = base_offset + base_len (file + base_offset);
316
317 if (! simple_backup_suffix)
318 set_simple_backup_suffix (NULL);
319
320 /* Allow room for simple or ".~N~" backups. The guess must be at
321 least sizeof ".~1~", but otherwise will be adjusted as needed. */
322 idx_t simple_backup_suffix_size = strlen (simple_backup_suffix) + 1;
323 idx_t backup_suffix_size_guess = simple_backup_suffix_size;
324 enum { GUESS = sizeof ".~12345~" };
325 if (backup_suffix_size_guess < GUESS)
326 backup_suffix_size_guess = GUESS;
327
328 idx_t ssize = filelen + backup_suffix_size_guess + 1;
329 char *s = imalloc (ssize);
330 if (!s)
331 return s;
332
333 DIR *dirp = NULL;
334 int sdir = -1;
335 idx_t base_max = 0;
336 while (true)
337 {
338 bool extended = true;
339 memcpy (s, file, filelen);
340
341 if (backup_type == simple_backups)
342 memcpy (s + filelen, simple_backup_suffix, simple_backup_suffix_size);
343 else
344 switch (numbered_backup (dir_fd, &s, ssize, filelen, base_offset,
345 &dirp, &sdir))
346 {
347 case BACKUP_IS_SAME_LENGTH:
348 break;
349
350 case BACKUP_IS_NEW:
351 if (backup_type == numbered_existing_backups)
352 {
353 backup_type = simple_backups;
354 memcpy (s + filelen, simple_backup_suffix,
355 simple_backup_suffix_size);
356 }
357 FALLTHROUGH;
358 case BACKUP_IS_LONGER:
359 extended = check_extension (s, filelen, '~', sdir, &base_max);
360 break;
361
362 case BACKUP_NOMEM:
363 if (dirp)
364 closedir (dirp);
365 free (s);
366 errno = ENOMEM;
367 return NULL;
368 }
369
370 if (! rename)
371 break;
372
373 dir_fd = sdir < 0 ? dir_fd : sdir;
374 idx_t offset = sdir < 0 ? 0 : base_offset;
375 unsigned flags = backup_type == simple_backups ? 0 : RENAME_NOREPLACE;
376 if (renameatu (dir_fd, file + offset, dir_fd, s + offset, flags) == 0)
377 break;
378 int e = errno;
379 if (! (e == EEXIST && extended))
380 {
381 if (dirp)
382 closedir (dirp);
383 free (s);
384 errno = e;
385 return NULL;
386 }
387 }
388
389 if (dirp)
390 closedir (dirp);
391 return s;
392 }