lib/backupfile.c

   1 /* backupfile.c -- make Emacs style backup file names
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; see the file COPYING.
  18    If not, write to the Free Software Foundation,
  19    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* Written by David MacKenzie <djm@gnu.ai.mit.edu>.
  22    Some algorithms adapted from GNU Emacs. */
  23
  24 #if HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #if HAVE_DIRENT_H
  33 # include <dirent.h>
  34 # define NLENGTH(direct) strlen ((direct)->d_name)
  35 #else
  36 # define dirent direct
  37 # define NLENGTH(direct) ((size_t) (direct)->d_namlen)
  38 # if HAVE_SYS_NDIR_H
  39 #  include <sys/ndir.h>
  40 # endif
  41 # if HAVE_SYS_DIR_H
  42 #  include <sys/dir.h>
  43 # endif
  44 # if HAVE_NDIR_H
  45 #  include <ndir.h>
  46 # endif
  47 #endif
  48
  49 #if CLOSEDIR_VOID
  50 /* Fake a return value. */
  51 # define CLOSEDIR(d) (closedir (d), 0)
  52 #else
  53 # define CLOSEDIR(d) closedir (d)
  54 #endif
  55
  56 #include <stdlib.h>
  57
  58 #if HAVE_DIRENT_H || HAVE_NDIR_H || HAVE_SYS_DIR_H || HAVE_SYS_NDIR_H
  59 # define HAVE_DIR 1
  60 #else
  61 # define HAVE_DIR 0
  62 #endif
  63
  64 #include <limits.h>
  65
  66 /* Upper bound on the string length of an integer converted to string.
  67    302 / 1000 is ceil (log10 (2.0)).  Subtract 1 for the sign bit;
  68    add 1 for integer division truncation; add 1 more for a minus sign.  */
  69 #define INT_STRLEN_BOUND(t) ((sizeof (t) * CHAR_BIT - 1) * 302 / 1000 + 2)
  70
  71 /* ISDIGIT differs from isdigit, as follows:
  72    - Its arg may be any int or unsigned int; it need not be an unsigned char.
  73    - It's guaranteed to evaluate its argument exactly once.
  74    - It's typically faster.
  75    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
  76    ISDIGIT_LOCALE unless it's important to use the locale's definition
  77    of `digit' even when the host does not conform to POSIX.  */
  78 #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
  79
  80 #if D_INO_IN_DIRENT
  81 # define REAL_DIR_ENTRY(dp) ((dp)->d_ino != 0)
  82 #else
  83 # define REAL_DIR_ENTRY(dp) 1
  84 #endif
  85
  86 #include "argmatch.h"
  87 #include "backupfile.h"
  88 #include "dirname.h"
  89
  90 /* The extension added to file names to produce a simple (as opposed
  91    to numbered) backup file name. */
  92 const char *simple_backup_suffix = "~";
  93
  94 static int max_backup_version (const char *, const char *);
  95 static int version_number (const char *, const char *, size_t);
  96
  97 /* Return the name of the new backup file for file FILE,
  98    allocated with malloc.  Return 0 if out of memory.
  99    FILE must not end with a '/' unless it is the root directory.
 100    Do not call this function if backup_type == none. */
 101
 102 char *
 103 find_backup_file_name (const char *file, enum backup_type backup_type)
 104 {
 105   size_t backup_suffix_size_max;
 106   size_t file_len = strlen (file);
 107   size_t numbered_suffix_size_max = INT_STRLEN_BOUND (int) + 4;
 108   char *s;
 109   const char *suffix = simple_backup_suffix;
 110
 111   /* Allow room for simple or `.~N~' backups.  */
 112   backup_suffix_size_max = strlen (simple_backup_suffix) + 1;
 113   if (HAVE_DIR && backup_suffix_size_max < numbered_suffix_size_max)
 114     backup_suffix_size_max = numbered_suffix_size_max;
 115
 116   s = malloc (file_len + 1
 117               + backup_suffix_size_max + numbered_suffix_size_max);
 118   if (s)
 119     {
 120 #if HAVE_DIR
 121       if (backup_type != simple)
 122         {
 123           int highest_backup;
 124           size_t dirlen = dir_len (file);
 125
 126           memcpy (s, file, dirlen);
 127           if (dirlen == FILESYSTEM_PREFIX_LEN (file))
 128             s[dirlen++] = '.';
 129           s[dirlen] = '\0';
 130           highest_backup = max_backup_version (base_name (file), s);
 131           if (! (backup_type == numbered_existing && highest_backup == 0))
 132             {
 133               char *numbered_suffix = s + (file_len + backup_suffix_size_max);
 134               sprintf (numbered_suffix, ".~%d~", highest_backup + 1);
 135               suffix = numbered_suffix;
 136             }
 137         }
 138 #endif /* HAVE_DIR */
 139
 140       strcpy (s, file);
 141       addext (s, suffix, '~');
 142     }
 143   return s;
 144 }
 145
 146 #if HAVE_DIR
 147
 148 /* Return the number of the highest-numbered backup file for file
 149    FILE in directory DIR.  If there are no numbered backups
 150    of FILE in DIR, or an error occurs reading DIR, return 0.
 151    */
 152
 153 static int
 154 max_backup_version (const char *file, const char *dir)
 155 {
 156   DIR *dirp;
 157   struct dirent *dp;
 158   int highest_version;
 159   int this_version;
 160   size_t file_name_length;
 161
 162   dirp = opendir (dir);
 163   if (!dirp)
 164     return 0;
 165
 166   highest_version = 0;
 167   file_name_length = base_len (file);
 168
 169   while ((dp = readdir (dirp)) != 0)
 170     {
 171       if (!REAL_DIR_ENTRY (dp) || NLENGTH (dp) < file_name_length + 4)
 172         continue;
 173
 174       this_version = version_number (file, dp->d_name, file_name_length);
 175       if (this_version > highest_version)
 176         highest_version = this_version;
 177     }
 178   if (CLOSEDIR (dirp))
 179     return 0;
 180   return highest_version;
 181 }
 182
 183 /* If BACKUP is a numbered backup of BASE, return its version number;
 184    otherwise return 0.  BASE_LENGTH is the length of BASE.
 185    */
 186
 187 static int
 188 version_number (const char *base, const char *backup, size_t base_length)
 189 {
 190   int version;
 191   const char *p;
 192
 193   version = 0;
 194   if (strncmp (base, backup, base_length) == 0
 195       && backup[base_length] == '.'
 196       && backup[base_length + 1] == '~')
 197     {
 198       for (p = &backup[base_length + 2]; ISDIGIT (*p); ++p)
 199         version = version * 10 + *p - '0';
 200       if (p[0] != '~' || p[1])
 201         version = 0;
 202     }
 203   return version;
 204 }
 205 #endif /* HAVE_DIR */
 206
 207 static const char * const backup_args[] =
 208 {
 209   /* In a series of synonyms, present the most meaning full first, so
 210      that argmatch_valid be more readable. */
 211   "none", "off",
 212   "simple", "never",
 213   "existing", "nil",
 214   "numbered", "t",
 215   0
 216 };
 217
 218 static const enum backup_type backup_types[] =
 219 {
 220   none, none,
 221   simple, simple,
 222   numbered_existing, numbered_existing,
 223   numbered, numbered
 224 };
 225
 226 /* Return the type of backup specified by VERSION.
 227    If VERSION is NULL or the empty string, return numbered_existing.
 228    If VERSION is invalid or ambiguous, fail with a diagnostic appropriate
 229    for the specified CONTEXT.  Unambiguous abbreviations are accepted.  */
 230
 231 enum backup_type
 232 get_version (const char *context, const char *version)
 233 {
 234   if (version == 0 || *version == 0)
 235     return numbered_existing;
 236   else
 237     return XARGMATCH (context, version, backup_args, backup_types);
 238 }
 239
 240
 241 /* Return the type of backup specified by VERSION.
 242    If VERSION is NULL, use the value of the envvar VERSION_CONTROL.
 243    If the specified string is invalid or ambiguous, fail with a diagnostic
 244    appropriate for the specified CONTEXT.
 245    Unambiguous abbreviations are accepted.  */
 246
 247 enum backup_type
 248 xget_version (const char *context, const char *version)
 249 {
 250   if (version && *version)
 251     return get_version (context, version);
 252   else
 253     return get_version ("$VERSION_CONTROL", getenv ("VERSION_CONTROL"));
 254 }