1/* backupfile.c -- make Emacs style backup file names
2
3   Copyright (C) 1990-2006, 2009-2010 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 <http://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 "backupfile.h"
24
25#include "argmatch.h"
26#include "dirname.h"
27#include "xalloc.h"
28
29#include <errno.h>
30#include <stdbool.h>
31#include <stdlib.h>
32#include <string.h>
33
34#include <limits.h>
35
36#include <unistd.h>
37
38#include "dirent--.h"
39#ifndef _D_EXACT_NAMLEN
40# define _D_EXACT_NAMLEN(dp) strlen ((dp)->d_name)
41#endif
42#if D_INO_IN_DIRENT
43# define REAL_DIR_ENTRY(dp) ((dp)->d_ino != 0)
44#else
45# define REAL_DIR_ENTRY(dp) 1
46#endif
47
48#if ! (HAVE_PATHCONF && defined _PC_NAME_MAX)
49# define pathconf(file, option) (errno = -1)
50#endif
51
52#ifndef _POSIX_NAME_MAX
53# define _POSIX_NAME_MAX 14
54#endif
55#ifndef SIZE_MAX
56# define SIZE_MAX ((size_t) -1)
57#endif
58
59#if defined _XOPEN_NAME_MAX
60# define NAME_MAX_MINIMUM _XOPEN_NAME_MAX
61#else
62# define NAME_MAX_MINIMUM _POSIX_NAME_MAX
63#endif
64
65#ifndef HAVE_DOS_FILE_NAMES
66# define HAVE_DOS_FILE_NAMES 0
67#endif
68#ifndef HAVE_LONG_FILE_NAMES
69# define HAVE_LONG_FILE_NAMES 0
70#endif
71
72/* ISDIGIT differs from isdigit, as follows:
73   - Its arg may be any int or unsigned int; it need not be an unsigned char
74     or EOF.
75   - It's typically faster.
76   POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
77   ISDIGIT unless it's important to use the locale's definition
78   of `digit' even when the host does not conform to POSIX.  */
79#define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
80
81/* The extension added to file names to produce a simple (as opposed
82   to numbered) backup file name. */
83char const *simple_backup_suffix = "~";
84
85
86/* If FILE (which was of length FILELEN before an extension was
87   appended to it) is too long, replace the extension with the single
88   char E.  If the result is still too long, remove the char just
89   before E.  */
90
91static void
92check_extension (char *file, size_t filelen, char e)
93{
94  char *base = last_component (file);
95  size_t baselen = base_len (base);
96  size_t baselen_max = HAVE_LONG_FILE_NAMES ? 255 : NAME_MAX_MINIMUM;
97
98  if (HAVE_DOS_FILE_NAMES || NAME_MAX_MINIMUM < baselen)
99    {
100      /* The new base name is long enough to require a pathconf check.  */
101      long name_max;
102
103      /* Temporarily modify the buffer into its parent directory name,
104         invoke pathconf on the directory, and then restore the buffer.  */
105      char tmp[sizeof "."];
106      memcpy (tmp, base, sizeof ".");
107      strcpy (base, ".");
108      errno = 0;
109      name_max = pathconf (file, _PC_NAME_MAX);
110      if (0 <= name_max || errno == 0)
111        {
112          long size = baselen_max = name_max;
113          if (name_max != size)
114            baselen_max = SIZE_MAX;
115        }
116      memcpy (base, tmp, sizeof ".");
117    }
118
119  if (HAVE_DOS_FILE_NAMES && baselen_max <= 12)
120    {
121      /* Live within DOS's 8.3 limit.  */
122      char *dot = strchr (base, '.');
123      if (!dot)
124        baselen_max = 8;
125      else
126        {
127          char const *second_dot = strchr (dot + 1, '.');
128          baselen_max = (second_dot
129                         ? second_dot - base
130                         : dot + 1 - base + 3);
131        }
132    }
133
134  if (baselen_max < baselen)
135    {
136      baselen = file + filelen - base;
137      if (baselen_max <= baselen)
138        baselen = baselen_max - 1;
139      base[baselen] = e;
140      base[baselen + 1] = '\0';
141    }
142}
143
144/* Returned values for NUMBERED_BACKUP.  */
145
146enum numbered_backup_result
147  {
148    /* The new backup name is the same length as an existing backup
149       name, so it's valid for that directory.  */
150    BACKUP_IS_SAME_LENGTH,
151
152    /* Some backup names already exist, but the returned name is longer
153       than any of them, and its length should be checked.  */
154    BACKUP_IS_LONGER,
155
156    /* There are no existing backup names.  The new name's length
157       should be checked.  */
158    BACKUP_IS_NEW
159  };
160
161/* *BUFFER contains a file name.  Store into *BUFFER the next backup
162   name for the named file, with a version number greater than all the
163   existing numbered backups.  Reallocate *BUFFER as necessary; its
164   initial allocated size is BUFFER_SIZE, which must be at least 4
165   bytes longer than the file name to make room for the initially
166   appended ".~1".  FILELEN is the length of the original file name.
167   The returned value indicates what kind of backup was found.  If an
168   I/O or other read error occurs, use the highest backup number that
169   was found.  */
170
171static enum numbered_backup_result
172numbered_backup (char **buffer, size_t buffer_size, size_t filelen)
173{
174  enum numbered_backup_result result = BACKUP_IS_NEW;
175  DIR *dirp;
176  struct dirent *dp;
177  char *buf = *buffer;
178  size_t versionlenmax = 1;
179  char *base = last_component (buf);
180  size_t base_offset = base - buf;
181  size_t baselen = base_len (base);
182
183  /* Temporarily modify the buffer into its parent directory name,
184     open the directory, and then restore the buffer.  */
185  char tmp[sizeof "."];
186  memcpy (tmp, base, sizeof ".");
187  strcpy (base, ".");
188  dirp = opendir (buf);
189  memcpy (base, tmp, sizeof ".");
190  strcpy (base + baselen, ".~1~");
191
192  if (!dirp)
193    return result;
194
195  while ((dp = readdir (dirp)) != NULL)
196    {
197      char const *p;
198      char *q;
199      bool all_9s;
200      size_t versionlen;
201      size_t new_buflen;
202
203      if (! REAL_DIR_ENTRY (dp) || _D_EXACT_NAMLEN (dp) < baselen + 4)
204        continue;
205
206      if (memcmp (buf + base_offset, dp->d_name, baselen + 2) != 0)
207        continue;
208
209      p = dp->d_name + baselen + 2;
210
211      /* Check whether this file has a version number and if so,
212         whether it is larger.  Use string operations rather than
213         integer arithmetic, to avoid problems with integer overflow.  */
214
215      if (! ('1' <= *p && *p <= '9'))
216        continue;
217      all_9s = (*p == '9');
218      for (versionlen = 1; ISDIGIT (p[versionlen]); versionlen++)
219        all_9s &= (p[versionlen] == '9');
220
221      if (! (p[versionlen] == '~' && !p[versionlen + 1]
222             && (versionlenmax < versionlen
223                 || (versionlenmax == versionlen
224                     && memcmp (buf + filelen + 2, p, versionlen) <= 0))))
225        continue;
226
227      /* This directory has the largest version number seen so far.
228         Append this highest numbered extension to the file name,
229         prepending '0' to the number if it is all 9s.  */
230
231      versionlenmax = all_9s + versionlen;
232      result = (all_9s ? BACKUP_IS_LONGER : BACKUP_IS_SAME_LENGTH);
233      new_buflen = filelen + 2 + versionlenmax + 1;
234      if (buffer_size <= new_buflen)
235        {
236          buf = xnrealloc (buf, 2, new_buflen);
237          buffer_size = new_buflen * 2;
238        }
239      q = buf + filelen;
240      *q++ = '.';
241      *q++ = '~';
242      *q = '0';
243      q += all_9s;
244      memcpy (q, p, versionlen + 2);
245
246      /* Add 1 to the version number.  */
247
248      q += versionlen;
249      while (*--q == '9')
250        *q = '0';
251      ++*q;
252    }
253
254  closedir (dirp);
255  *buffer = buf;
256  return result;
257}
258
259/* Return the name of the new backup file for the existing file FILE,
260   allocated with malloc.  Report an error and fail if out of memory.
261   Do not call this function if backup_type == no_backups.  */
262
263char *
264find_backup_file_name (char const *file, enum backup_type backup_type)
265{
266  size_t filelen = strlen (file);
267  char *s;
268  size_t ssize;
269  bool simple = true;
270
271  /* Allow room for simple or ".~N~" backups.  The guess must be at
272     least sizeof ".~1~", but otherwise will be adjusted as needed.  */
273  size_t simple_backup_suffix_size = strlen (simple_backup_suffix) + 1;
274  size_t backup_suffix_size_guess = simple_backup_suffix_size;
275  enum { GUESS = sizeof ".~12345~" };
276  if (backup_suffix_size_guess < GUESS)
277    backup_suffix_size_guess = GUESS;
278
279  ssize = filelen + backup_suffix_size_guess + 1;
280  s = xmalloc (ssize);
281  memcpy (s, file, filelen + 1);
282
283  if (backup_type != simple_backups)
284    switch (numbered_backup (&s, ssize, filelen))
285      {
286      case BACKUP_IS_SAME_LENGTH:
287        return s;
288
289      case BACKUP_IS_LONGER:
290        simple = false;
291        break;
292
293      case BACKUP_IS_NEW:
294        simple = (backup_type == numbered_existing_backups);
295        break;
296      }
297
298  if (simple)
299    memcpy (s + filelen, simple_backup_suffix, simple_backup_suffix_size);
300  check_extension (s, filelen, '~');
301  return s;
302}
303
304static char const * const backup_args[] =
305{
306  /* In a series of synonyms, present the most meaningful first, so
307     that argmatch_valid be more readable. */
308  "none", "off",
309  "simple", "never",
310  "existing", "nil",
311  "numbered", "t",
312  NULL
313};
314
315static const enum backup_type backup_types[] =
316{
317  no_backups, no_backups,
318  simple_backups, simple_backups,
319  numbered_existing_backups, numbered_existing_backups,
320  numbered_backups, numbered_backups
321};
322
323/* Ensure that these two vectors have the same number of elements,
324   not counting the final NULL in the first one.  */
325ARGMATCH_VERIFY (backup_args, backup_types);
326
327/* Return the type of backup specified by VERSION.
328   If VERSION is NULL or the empty string, return numbered_existing_backups.
329   If VERSION is invalid or ambiguous, fail with a diagnostic appropriate
330   for the specified CONTEXT.  Unambiguous abbreviations are accepted.  */
331
332enum backup_type
333get_version (char const *context, char const *version)
334{
335  if (version == 0 || *version == 0)
336    return numbered_existing_backups;
337  else
338    return XARGMATCH (context, version, backup_args, backup_types);
339}
340
341
342/* Return the type of backup specified by VERSION.
343   If VERSION is NULL, use the value of the envvar VERSION_CONTROL.
344   If the specified string is invalid or ambiguous, fail with a diagnostic
345   appropriate for the specified CONTEXT.
346   Unambiguous abbreviations are accepted.  */
347
348enum backup_type
349xget_version (char const *context, char const *version)
350{
351  if (version && *version)
352    return get_version (context, version);
353  else
354    return get_version ("$VERSION_CONTROL", getenv ("VERSION_CONTROL"));
355}
356