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 <stdio.h>
  29 #include <sys/types.h>
  30 #if HAVE_STRING_H
  31 # include <string.h>
  32 #else
  33 # include <strings.h>
  34 #endif
  35
  36 #if HAVE_DIRENT_H
  37 # include <dirent.h>
  38 # define NLENGTH(direct) strlen ((direct)->d_name)
  39 #else
  40 # define dirent direct
  41 # define NLENGTH(direct) ((size_t) (direct)->d_namlen)
  42 # if HAVE_SYS_NDIR_H
  43 #  include <sys/ndir.h>
  44 # endif
  45 # if HAVE_SYS_DIR_H
  46 #  include <sys/dir.h>
  47 # endif
  48 # if HAVE_NDIR_H
  49 #  include <ndir.h>
  50 # endif
  51 #endif
  52
  53 #if CLOSEDIR_VOID
  54 /* Fake a return value. */
  55 # define CLOSEDIR(d) (closedir (d), 0)
  56 #else
  57 # define CLOSEDIR(d) closedir (d)
  58 #endif
  59
  60 #if HAVE_STDLIB_H
  61 # include <stdlib.h>
  62 #endif
  63
  64 #ifndef HAVE_DECL_GETENV
  65 "this configure-time declaration test was not run"
  66 #endif
  67 #if !HAVE_DECL_GETENV
  68 char *getenv ();
  69 #endif
  70
  71 #ifndef HAVE_DECL_MALLOC
  72 "this configure-time declaration test was not run"
  73 #endif
  74 #if !HAVE_DECL_MALLOC
  75 char *malloc ();
  76 #endif
  77
  78 #if HAVE_DIRENT_H || HAVE_NDIR_H || HAVE_SYS_DIR_H || HAVE_SYS_NDIR_H
  79 # define HAVE_DIR 1
  80 #else
  81 # define HAVE_DIR 0
  82 #endif
  83
  84 #include <limits.h>
  85
  86 /* Upper bound on the string length of an integer converted to string.
  87    302 / 1000 is ceil (log10 (2.0)).  Subtract 1 for the sign bit;
  88    add 1 for integer division truncation; add 1 more for a minus sign.  */
  89 #define INT_STRLEN_BOUND(t) ((sizeof (t) * CHAR_BIT - 1) * 302 / 1000 + 2)
  90
  91 /* ISDIGIT differs from isdigit, as follows:
  92    - Its arg may be any int or unsigned int; it need not be an unsigned char.
  93    - It's guaranteed to evaluate its argument exactly once.
  94    - It's typically faster.
  95    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
  96    ISDIGIT_LOCALE unless it's important to use the locale's definition
  97    of `digit' even when the host does not conform to POSIX.  */
  98 #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
  99
 100 #if D_INO_IN_DIRENT
 101 # define REAL_DIR_ENTRY(dp) ((dp)->d_ino != 0)
 102 #else
 103 # define REAL_DIR_ENTRY(dp) 1
 104 #endif
 105
 106 #include "argmatch.h"
 107 #include "backupfile.h"
 108 #include "dirname.h"
 109
 110 /* The extension added to file names to produce a simple (as opposed
 111    to numbered) backup file name. */
 112 const char *simple_backup_suffix = "~";
 113
 114 static int max_backup_version PARAMS ((const char *, const char *));
 115 static int version_number PARAMS ((const char *, const char *, size_t));
 116
 117 /* Return the name of the new backup file for file FILE,
 118    allocated with malloc.  Return 0 if out of memory.
 119    FILE must not end with a '/' unless it is the root directory.
 120    Do not call this function if backup_type == none. */
 121
 122 char *
 123 find_backup_file_name (const char *file, enum backup_type backup_type)
 124 {
 125   size_t backup_suffix_size_max;
 126   size_t file_len = strlen (file);
 127   size_t numbered_suffix_size_max = INT_STRLEN_BOUND (int) + 4;
 128   char *s;
 129   const char *suffix = simple_backup_suffix;
 130
 131   /* Allow room for simple or `.~N~' backups.  */
 132   backup_suffix_size_max = strlen (simple_backup_suffix) + 1;
 133   if (HAVE_DIR && backup_suffix_size_max < numbered_suffix_size_max)
 134     backup_suffix_size_max = numbered_suffix_size_max;
 135
 136   s = malloc (file_len + 1
 137               + backup_suffix_size_max + numbered_suffix_size_max);
 138   if (s)
 139     {
 140 #if HAVE_DIR
 141       if (backup_type != simple)
 142         {
 143           int highest_backup;
 144           size_t dirlen = dir_len (file);
 145
 146           memcpy (s, file, dirlen);
 147           if (dirlen == FILESYSTEM_PREFIX_LEN (file))
 148             s[dirlen++] = '.';
 149           s[dirlen] = '\0';
 150           highest_backup = max_backup_version (base_name (file), s);
 151           if (! (backup_type == numbered_existing && highest_backup == 0))
 152             {
 153               char *numbered_suffix = s + (file_len + backup_suffix_size_max);
 154               sprintf (numbered_suffix, ".~%d~", highest_backup + 1);
 155               suffix = numbered_suffix;
 156             }
 157         }
 158 #endif /* HAVE_DIR */
 159
 160       strcpy (s, file);
 161       addext (s, suffix, '~');
 162     }
 163   return s;
 164 }
 165
 166 #if HAVE_DIR
 167
 168 /* Return the number of the highest-numbered backup file for file
 169    FILE in directory DIR.  If there are no numbered backups
 170    of FILE in DIR, or an error occurs reading DIR, return 0.
 171    */
 172
 173 static int
 174 max_backup_version (const char *file, const char *dir)
 175 {
 176   DIR *dirp;
 177   struct dirent *dp;
 178   int highest_version;
 179   int this_version;
 180   size_t file_name_length;
 181
 182   dirp = opendir (dir);
 183   if (!dirp)
 184     return 0;
 185
 186   highest_version = 0;
 187   file_name_length = base_len (file);
 188
 189   while ((dp = readdir (dirp)) != 0)
 190     {
 191       if (!REAL_DIR_ENTRY (dp) || NLENGTH (dp) < file_name_length + 4)
 192         continue;
 193
 194       this_version = version_number (file, dp->d_name, file_name_length);
 195       if (this_version > highest_version)
 196         highest_version = this_version;
 197     }
 198   if (CLOSEDIR (dirp))
 199     return 0;
 200   return highest_version;
 201 }
 202
 203 /* If BACKUP is a numbered backup of BASE, return its version number;
 204    otherwise return 0.  BASE_LENGTH is the length of BASE.
 205    */
 206
 207 static int
 208 version_number (const char *base, const char *backup, size_t base_length)
 209 {
 210   int version;
 211   const char *p;
 212
 213   version = 0;
 214   if (strncmp (base, backup, base_length) == 0
 215       && backup[base_length] == '.'
 216       && backup[base_length + 1] == '~')
 217     {
 218       for (p = &backup[base_length + 2]; ISDIGIT (*p); ++p)
 219         version = version * 10 + *p - '0';
 220       if (p[0] != '~' || p[1])
 221         version = 0;
 222     }
 223   return version;
 224 }
 225 #endif /* HAVE_DIR */
 226
 227 static const char * const backup_args[] =
 228 {
 229   /* In a series of synonyms, present the most meaning full first, so
 230      that argmatch_valid be more readable. */
 231   "none", "off",
 232   "simple", "never",
 233   "existing", "nil",
 234   "numbered", "t",
 235   0
 236 };
 237
 238 static const enum backup_type backup_types[] =
 239 {
 240   none, none,
 241   simple, simple,
 242   numbered_existing, numbered_existing,
 243   numbered, numbered
 244 };
 245
 246 /* Return the type of backup specified by VERSION.
 247    If VERSION is NULL or the empty string, return numbered_existing.
 248    If VERSION is invalid or ambiguous, fail with a diagnostic appropriate
 249    for the specified CONTEXT.  Unambiguous abbreviations are accepted.  */
 250
 251 enum backup_type
 252 get_version (const char *context, const char *version)
 253 {
 254   if (version == 0 || *version == 0)
 255     return numbered_existing;
 256   else
 257     return XARGMATCH (context, version, backup_args, backup_types);
 258 }
 259
 260
 261 /* Return the type of backup specified by VERSION.
 262    If VERSION is NULL, use the value of the envvar VERSION_CONTROL.
 263    If the specified string is invalid or ambiguous, fail with a diagnostic
 264    appropriate for the specified CONTEXT.
 265    Unambiguous abbreviations are accepted.  */
 266
 267 enum backup_type
 268 xget_version (const char *context, const char *version)
 269 {
 270   if (version && *version)
 271     return get_version (context, version);
 272   else
 273     return get_version ("$VERSION_CONTROL", getenv ("VERSION_CONTROL"));
 274 }