src/truncate.c

   1 /* truncate -- truncate or extend the length of files.
   2    Copyright (C) 2008-2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Pádraig Brady
  18
  19    This is backwards compatible with the FreeBSD utility, but is more
  20    flexible wrt the size specifications and the use of long options,
  21    to better fit the "GNU" environment.
  22
  23    Note if !defined(HAVE_FTRUNCATE) then the --skip-ftruncate configure flag
  24    was specified or we're in a mingw environment. In these cases gnulib
  25    emulation will be used and GNULIB_FTRUNCATE is defined. Note if emulation
  26    can't even be provided ftruncate() will return EIO.  */
  27
  28 #include <config.h>             /* sets _FILE_OFFSET_BITS=64 etc. */
  29 #include <stdio.h>
  30 #include <getopt.h>
  31 #include <sys/types.h>
  32
  33 #include "system.h"
  34 #include "error.h"
  35 #include "posixver.h"
  36 #include "quote.h"
  37 #include "xstrtol.h"
  38
  39 /* The official name of this program (e.g., no `g' prefix).  */
  40 #define PROGRAM_NAME "truncate"
  41
  42 #define AUTHORS proper_name_utf8 ("Padraig Brady", "P\303\241draig Brady")
  43
  44 /* (-c) If true, don't create if not already there */
  45 static bool no_create;
  46
  47 /* (-o) If true, --size refers to blocks not bytes */
  48 static bool block_mode;
  49
  50 /* (-r) Reference file to use size from */
  51 static char const *ref_file;
  52
  53 static struct option const longopts[] =
  54 {
  55   {"no-create", no_argument, NULL, 'c'},
  56   {"io-blocks", no_argument, NULL, 'o'},
  57   {"reference", required_argument, NULL, 'r'},
  58   {"size", required_argument, NULL, 's'},
  59   {GETOPT_HELP_OPTION_DECL},
  60   {GETOPT_VERSION_OPTION_DECL},
  61   {NULL, 0, NULL, 0}
  62 };
  63
  64 typedef enum
  65 { rm_abs = 0, rm_rel, rm_min, rm_max, rm_rdn, rm_rup } rel_mode_t;
  66
  67 /* Set size to the value of STR, interpreted as a decimal integer,
  68    optionally multiplied by various values.
  69    Return -1 on error, 0 on success.
  70
  71    This supports dd BLOCK size suffixes + lowercase g,t,m for bsd compat
  72    Note we don't support dd's b=512, c=1, w=2 or 21x512MiB formats.  */
  73 static int
  74 parse_len (char const *str, off_t *size)
  75 {
  76   enum strtol_error e;
  77   intmax_t tmp_size;
  78   e = xstrtoimax (str, NULL, 10, &tmp_size, "EgGkKmMPtTYZ0");
  79   if (e == LONGINT_OK
  80       && !(OFF_T_MIN <= tmp_size && tmp_size <= OFF_T_MAX))
  81     e = LONGINT_OVERFLOW;
  82
  83   if (e == LONGINT_OK)
  84     {
  85       errno = 0;
  86       *size = tmp_size;
  87       return 0;
  88     }
  89
  90   errno = (e == LONGINT_OVERFLOW ? EOVERFLOW : 0);
  91   return -1;
  92 }
  93
  94 void
  95 usage (int status)
  96 {
  97   if (status != EXIT_SUCCESS)
  98     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  99              program_name);
 100   else
 101     {
 102       printf (_("Usage: %s OPTION... FILE...\n"), program_name);
 103       fputs (_("\
 104 Shrink or extend the size of each FILE to the specified size\n\
 105 \n\
 106 A FILE argument that does not exist is created.\n\
 107 \n\
 108 If a FILE is larger than the specified size, the extra data is lost.\n\
 109 If a FILE is shorter, it is extended and the extended part (hole)\n\
 110 reads as zero bytes.\n\
 111 \n\
 112 "), stdout);
 113       fputs (_("\
 114 Mandatory arguments to long options are mandatory for short options too.\n\
 115 "), stdout);
 116       fputs (_("\
 117   -c, --no-create        do not create any files\n\
 118 "), stdout);
 119       fputs (_("\
 120   -o, --io-blocks        Treat SIZE as number of IO blocks instead of bytes\n\
 121 "), stdout);
 122       fputs (_("\
 123   -r, --reference=FILE   use this FILE's size\n\
 124   -s, --size=SIZE        use this SIZE\n"), stdout);
 125       fputs (HELP_OPTION_DESCRIPTION, stdout);
 126       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 127       fputs (_("\n\
 128 SIZE is a number which may be followed by one of the following suffixes:\n\
 129 KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
 130 "), stdout);
 131       fputs (_("\n\
 132 SIZE may also be prefixed by one of the following modifying characters:\n\
 133 `+' extend by, `-' reduce by, `<' at most, `>' at least,\n\
 134 `/' round down to multiple of, `%' round up to multiple of.\n"), stdout);
 135       fputs (_("\
 136 \n\
 137 Note that the -r and -s options are mutually exclusive.\n\
 138 "), stdout);
 139       emit_bug_reporting_address ();
 140     }
 141   exit (status);
 142 }
 143
 144 /* return 1 on error, 0 on success */
 145 static int
 146 do_ftruncate (int fd, char const *fname, off_t ssize, rel_mode_t rel_mode)
 147 {
 148   struct stat sb;
 149   off_t nsize;
 150
 151   if ((block_mode || rel_mode) && fstat (fd, &sb) != 0)
 152     {
 153       error (0, errno, _("cannot fstat %s"), quote (fname));
 154       return 1;
 155     }
 156   if (block_mode)
 157     {
 158       off_t const blksize = ST_BLKSIZE (sb);
 159       if (ssize < OFF_T_MIN / blksize || ssize > OFF_T_MAX / blksize)
 160         {
 161           error (0, 0,
 162                  _("overflow in %" PRIdMAX
 163                    " * %" PRIdMAX " byte blocks for file %s"),
 164                  (intmax_t) ssize, (intmax_t) blksize,
 165                  quote (fname));
 166           return 1;
 167         }
 168       ssize *= blksize;
 169     }
 170   if (rel_mode)
 171     {
 172       uintmax_t const fsize = sb.st_size;
 173
 174       if (sb.st_size < 0)
 175         {
 176           /* Complain only for a regular file, a directory,
 177              or a shared memory object, as POSIX 1003.1-2004 specifies
 178              ftruncate's behavior only for these file types.  */
 179           if (S_ISREG (sb.st_mode) || S_ISDIR (sb.st_mode)
 180               || S_TYPEISSHM (&sb))
 181             {
 182               /* overflow is the only reason I can think
 183                  this would ever go negative for the above types */
 184               error (0, 0, _("%s has unusable, apparently negative size"),
 185                      quote (fname));
 186               return 1;
 187             }
 188           return 0;
 189         }
 190
 191       if (rel_mode == rm_min)
 192         nsize = MAX (fsize, (uintmax_t) ssize);
 193       else if (rel_mode == rm_max)
 194         nsize = MIN (fsize, (uintmax_t) ssize);
 195       else if (rel_mode == rm_rdn)
 196         /* 0..ssize-1 -> 0 */
 197         nsize = (fsize / ssize) * ssize;
 198       else if (rel_mode == rm_rup)
 199         /* 1..ssize -> ssize */
 200         {
 201           /* Here ssize>=1 && fsize>=0 */
 202           uintmax_t const overflow = ((fsize + ssize - 1) / ssize) * ssize;
 203           if (overflow > OFF_T_MAX)
 204             {
 205               error (0, 0, _("overflow rounding up size of file %s"),
 206                      quote (fname));
 207               return 1;
 208             }
 209           nsize = overflow;
 210         }
 211       else
 212         {
 213           if (ssize > OFF_T_MAX - (off_t)fsize)
 214             {
 215               error (0, 0, _("overflow extending size of file %s"),
 216                      quote (fname));
 217               return 1;
 218             }
 219           nsize = fsize + ssize;
 220         }
 221     }
 222   else
 223     nsize = ssize;
 224   if (nsize < 0)
 225     nsize = 0;
 226
 227   if (ftruncate (fd, nsize) == -1)      /* note updates mtime & ctime */
 228     {
 229       /* Complain only when ftruncate fails on a regular file, a
 230          directory, or a shared memory object, as POSIX 1003.1-2004
 231          specifies ftruncate's behavior only for these file types.
 232          For example, do not complain when Linux kernel 2.4 ftruncate
 233          fails on /dev/fd0.  */
 234       int const ftruncate_errno = errno;
 235       if (fstat (fd, &sb) != 0)
 236         {
 237           error (0, errno, _("cannot fstat %s"), quote (fname));
 238           return 1;
 239         }
 240       else if (S_ISREG (sb.st_mode) || S_ISDIR (sb.st_mode)
 241                || S_TYPEISSHM (&sb))
 242         {
 243           error (0, ftruncate_errno,
 244                  _("truncating %s at %" PRIdMAX " bytes"), quote (fname),
 245                  (intmax_t) nsize);
 246           return 1;
 247         }
 248       return 0;
 249     }
 250
 251   return 0;
 252 }
 253
 254 int
 255 main (int argc, char **argv)
 256 {
 257   bool got_size = false;
 258   off_t size IF_LINT (= 0);
 259   rel_mode_t rel_mode = rm_abs;
 260   mode_t omode;
 261   int c, errors = 0, fd = -1, oflags;
 262   char const *fname;
 263
 264   initialize_main (&argc, &argv);
 265   set_program_name (argv[0]);
 266   setlocale (LC_ALL, "");
 267   bindtextdomain (PACKAGE, LOCALEDIR);
 268   textdomain (PACKAGE);
 269
 270   atexit (close_stdout);
 271
 272   while ((c = getopt_long (argc, argv, "cor:s:", longopts, NULL)) != -1)
 273     {
 274       switch (c)
 275         {
 276         case 'c':
 277           no_create = true;
 278           break;
 279
 280         case 'o':
 281           block_mode = true;
 282           break;
 283
 284         case 'r':
 285           ref_file = optarg;
 286           break;
 287
 288         case 's':
 289           /* skip any whitespace */
 290           while (isspace (to_uchar (*optarg)))
 291             optarg++;
 292           switch (*optarg)
 293             {
 294             case '<':
 295               rel_mode = rm_max;
 296               optarg++;
 297               break;
 298             case '>':
 299               rel_mode = rm_min;
 300               optarg++;
 301               break;
 302             case '/':
 303               rel_mode = rm_rdn;
 304               optarg++;
 305               break;
 306             case '%':
 307               rel_mode = rm_rup;
 308               optarg++;
 309               break;
 310             }
 311           /* skip any whitespace */
 312           while (isspace (to_uchar (*optarg)))
 313             optarg++;
 314           if (*optarg == '+' || *optarg == '-')
 315             {
 316               if (rel_mode)
 317                 {
 318                   error (0, 0, _("multiple relative modifiers specified"));
 319                   /* Note other combinations are flagged as invalid numbers */
 320                   usage (EXIT_FAILURE);
 321                 }
 322               rel_mode = rm_rel;
 323             }
 324           if (parse_len (optarg, &size) == -1)
 325             error (EXIT_FAILURE, errno, _("invalid number %s"),
 326                    quote (optarg));
 327           /* Rounding to multiple of 0 is nonsensical */
 328           if ((rel_mode == rm_rup || rel_mode == rm_rdn) && size == 0)
 329             error (EXIT_FAILURE, 0, _("division by zero"));
 330           got_size = true;
 331           break;
 332
 333         case_GETOPT_HELP_CHAR;
 334
 335         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 336
 337         default:
 338           usage (EXIT_FAILURE);
 339         }
 340     }
 341
 342   argv += optind;
 343   argc -= optind;
 344
 345   /* must specify either size or reference file */
 346   if ((ref_file && got_size) || (!ref_file && !got_size))
 347     {
 348       error (0, 0, _("you must specify one of %s or %s"),
 349              quote_n (0, "--size"), quote_n (1, "--reference"));
 350       usage (EXIT_FAILURE);
 351     }
 352   /* block_mode without size is not valid */
 353   if (block_mode && !got_size)
 354     {
 355       error (0, 0, _("%s was specified but %s was not"),
 356              quote_n (0, "--io-blocks"), quote_n (1, "--size"));
 357       usage (EXIT_FAILURE);
 358     }
 359   /* must specify at least 1 file */
 360   if (argc < 1)
 361     {
 362       error (0, 0, _("missing file operand"));
 363       usage (EXIT_FAILURE);
 364     }
 365
 366   if (ref_file)
 367     {
 368       struct stat sb;
 369       if (stat (ref_file, &sb) != 0)
 370         error (EXIT_FAILURE, errno, _("cannot stat %s"), quote (ref_file));
 371       size = sb.st_size;
 372     }
 373
 374   oflags = O_WRONLY | (no_create ? 0 : O_CREAT) | O_NONBLOCK;
 375   omode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 376
 377   while ((fname = *argv++) != NULL)
 378     {
 379       if ((fd = open (fname, oflags, omode)) == -1)
 380         {
 381           /* `truncate -s0 -c no-such-file`  shouldn't gen error
 382              `truncate -s0 no-such-dir/file` should gen ENOENT error
 383              `truncate -s0 no-such-dir/` should gen EISDIR error
 384              `truncate -s0 .` should gen EISDIR error */
 385           if (!(no_create && errno == ENOENT))
 386             {
 387               int const open_errno = errno;
 388               struct stat sb;
 389               if (stat (fname, &sb) == 0)
 390                 {
 391                   /* Complain only for a regular file, a directory,
 392                      or a shared memory object, as POSIX 1003.1-2004 specifies
 393                      ftruncate's behavior only for these file types.  */
 394                   if (!S_ISREG (sb.st_mode) && !S_ISDIR (sb.st_mode)
 395                       && !S_TYPEISSHM (&sb))
 396                     continue;
 397                 }
 398               error (0, open_errno, _("cannot open %s for writing"),
 399                      quote (fname));
 400               errors++;
 401             }
 402           continue;
 403         }
 404
 405
 406       if (fd != -1)
 407         {
 408           errors += do_ftruncate (fd, fname, size, rel_mode);
 409           if (close (fd) != 0)
 410             {
 411               error (0, errno, _("closing %s"), quote (fname));
 412               errors++;
 413             }
 414         }
 415     }
 416
 417   return errors ? EXIT_FAILURE : EXIT_SUCCESS;
 418 }
 419
 420 /*
 421  * Local variables:
 422  *  indent-tabs-mode: nil
 423  * End:
 424  */