src/truncate.c

   1 /* truncate -- truncate or extend the length of files.
   2    Copyright (C) 2008 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 static 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 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           switch (*optarg)
 290             {
 291             case '<':
 292               rel_mode = rm_max;
 293               optarg++;
 294               break;
 295             case '>':
 296               rel_mode = rm_min;
 297               optarg++;
 298               break;
 299             case '/':
 300               rel_mode = rm_rdn;
 301               optarg++;
 302               break;
 303             case '%':
 304               rel_mode = rm_rup;
 305               optarg++;
 306               break;
 307             }
 308           if (*optarg == '+' || *optarg == '-')
 309             {
 310               if (rel_mode)
 311                 {
 312                   error (0, 0, _("multiple relative modifiers specified"));
 313                   /* Note other combinations are flagged as invalid numbers */
 314                   usage (EXIT_FAILURE);
 315                 }
 316               rel_mode = rm_rel;
 317             }
 318           if (parse_len (optarg, &size) == -1)
 319             error (EXIT_FAILURE, errno, _("invalid number %s"),
 320                    quote (optarg));
 321           /* Rounding to multiple of 0 is nonsensical */
 322           if ((rel_mode == rm_rup || rel_mode == rm_rdn) && size == 0)
 323             error (EXIT_FAILURE, 0, _("division by zero"));
 324           got_size = true;
 325           break;
 326
 327         case_GETOPT_HELP_CHAR;
 328
 329         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 330
 331         default:
 332           usage (EXIT_FAILURE);
 333         }
 334     }
 335
 336   argv += optind;
 337   argc -= optind;
 338
 339   /* must specify either size or reference file */
 340   if ((ref_file && got_size) || (!ref_file && !got_size))
 341     {
 342       error (0, 0, _("you must specify one of %s or %s"),
 343              quote_n (0, "--size"), quote_n (1, "--reference"));
 344       usage (EXIT_FAILURE);
 345     }
 346   /* block_mode without size is not valid */
 347   if (block_mode && !got_size)
 348     {
 349       error (0, 0, _("%s was specified but %s was not"),
 350              quote_n (0, "--io-blocks"), quote_n (1, "--size"));
 351       usage (EXIT_FAILURE);
 352     }
 353   /* must specify at least 1 file */
 354   if (argc < 1)
 355     {
 356       error (0, 0, _("missing file operand"));
 357       usage (EXIT_FAILURE);
 358     }
 359
 360   if (ref_file)
 361     {
 362       struct stat sb;
 363       if (stat (ref_file, &sb) != 0)
 364         error (EXIT_FAILURE, errno, _("cannot stat %s"), quote (ref_file));
 365       size = sb.st_size;
 366     }
 367
 368   oflags = O_WRONLY | (no_create ? 0 : O_CREAT) | O_NONBLOCK;
 369   omode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 370
 371   while ((fname = *argv++) != NULL)
 372     {
 373       if ((fd = open (fname, oflags, omode)) == -1)
 374         {
 375           /* `truncate -s0 -c no-such-file`  shouldn't gen error
 376              `truncate -s0 no-such-dir/file` should gen ENOENT error
 377              `truncate -s0 no-such-dir/` should gen EISDIR error
 378              `truncate -s0 .` should gen EISDIR error */
 379           if (!(no_create && errno == ENOENT))
 380             {
 381               int const open_errno = errno;
 382               struct stat sb;
 383               if (stat (fname, &sb) == 0)
 384                 {
 385                   /* Complain only for a regular file, a directory,
 386                      or a shared memory object, as POSIX 1003.1-2004 specifies
 387                      ftruncate's behavior only for these file types.  */
 388                   if (!S_ISREG (sb.st_mode) && !S_ISDIR (sb.st_mode)
 389                       && !S_TYPEISSHM (&sb))
 390                     continue;
 391                 }
 392               error (0, open_errno, _("cannot open %s for writing"),
 393                      quote (fname));
 394               errors++;
 395             }
 396           continue;
 397         }
 398
 399
 400       if (fd != -1)
 401         {
 402           errors += do_ftruncate (fd, fname, size, rel_mode);
 403           if (close (fd) != 0)
 404             {
 405               error (0, errno, _("closing %s"), quote (fname));
 406               errors++;
 407             }
 408         }
 409     }
 410
 411   return errors ? EXIT_FAILURE : EXIT_SUCCESS;
 412 }
 413
 414 /*
 415  * Local variables:
 416  *  indent-tabs-mode: nil
 417  * End:
 418  */