src/truncate.c

   1 /* truncate -- truncate or extend the length of files.
   2    Copyright (C) 2008-2023 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 <https://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 #include <config.h>             /* sets _FILE_OFFSET_BITS=64 etc. */
  24 #include <stdio.h>
  25 #include <getopt.h>
  26 #include <sys/types.h>
  27
  28 #include "system.h"
  29 #include "die.h"
  30 #include "error.h"
  31 #include "quote.h"
  32 #include "stat-size.h"
  33 #include "xdectoint.h"
  34
  35 /* The official name of this program (e.g., no 'g' prefix).  */
  36 #define PROGRAM_NAME "truncate"
  37
  38 #define AUTHORS proper_name ("Padraig Brady")
  39
  40 /* (-c) If true, don't create if not already there */
  41 static bool no_create;
  42
  43 /* (-o) If true, --size refers to blocks not bytes */
  44 static bool block_mode;
  45
  46 /* (-r) Reference file to use size from */
  47 static char const *ref_file;
  48
  49 static struct option const longopts[] =
  50 {
  51   {"no-create", no_argument, nullptr, 'c'},
  52   {"io-blocks", no_argument, nullptr, 'o'},
  53   {"reference", required_argument, nullptr, 'r'},
  54   {"size", required_argument, nullptr, 's'},
  55   {GETOPT_HELP_OPTION_DECL},
  56   {GETOPT_VERSION_OPTION_DECL},
  57   {nullptr, 0, nullptr, 0}
  58 };
  59
  60 typedef enum
  61 { rm_abs = 0, rm_rel, rm_min, rm_max, rm_rdn, rm_rup } rel_mode_t;
  62
  63 void
  64 usage (int status)
  65 {
  66   if (status != EXIT_SUCCESS)
  67     emit_try_help ();
  68   else
  69     {
  70       printf (_("Usage: %s OPTION... FILE...\n"), program_name);
  71       fputs (_("\
  72 Shrink or extend the size of each FILE to the specified size\n\
  73 \n\
  74 A FILE argument that does not exist is created.\n\
  75 \n\
  76 If a FILE is larger than the specified size, the extra data is lost.\n\
  77 If a FILE is shorter, it is extended and the sparse extended part (hole)\n\
  78 reads as zero bytes.\n\
  79 "), stdout);
  80
  81       emit_mandatory_arg_note ();
  82
  83       fputs (_("\
  84   -c, --no-create        do not create any files\n\
  85 "), stdout);
  86       fputs (_("\
  87   -o, --io-blocks        treat SIZE as number of IO blocks instead of bytes\n\
  88 "), stdout);
  89       fputs (_("\
  90   -r, --reference=RFILE  base size on RFILE\n\
  91   -s, --size=SIZE        set or adjust the file size by SIZE bytes\n"), stdout);
  92       fputs (HELP_OPTION_DESCRIPTION, stdout);
  93       fputs (VERSION_OPTION_DESCRIPTION, stdout);
  94       emit_size_note ();
  95       fputs (_("\n\
  96 SIZE may also be prefixed by one of the following modifying characters:\n\
  97 '+' extend by, '-' reduce by, '<' at most, '>' at least,\n\
  98 '/' round down to multiple of, '%' round up to multiple of.\n"), stdout);
  99       emit_ancillary_info (PROGRAM_NAME);
 100     }
 101   exit (status);
 102 }
 103
 104 /* return true on success, false on error.  */
 105 static bool
 106 do_ftruncate (int fd, char const *fname, off_t ssize, off_t rsize,
 107               rel_mode_t rel_mode)
 108 {
 109   struct stat sb;
 110   off_t nsize;
 111
 112   if ((block_mode || (rel_mode && rsize < 0)) && fstat (fd, &sb) != 0)
 113     {
 114       error (0, errno, _("cannot fstat %s"), quoteaf (fname));
 115       return false;
 116     }
 117   if (block_mode)
 118     {
 119       ptrdiff_t blksize = ST_BLKSIZE (sb);
 120       intmax_t ssize0 = ssize;
 121       if (INT_MULTIPLY_WRAPV (ssize, blksize, &ssize))
 122         {
 123           error (0, 0,
 124                  _("overflow in %" PRIdMAX
 125                    " * %" PRIdPTR " byte blocks for file %s"),
 126                  ssize0, blksize, quoteaf (fname));
 127           return false;
 128         }
 129     }
 130   if (rel_mode)
 131     {
 132       off_t fsize;
 133
 134       if (0 <= rsize)
 135         fsize = rsize;
 136       else
 137         {
 138           if (usable_st_size (&sb))
 139             {
 140               fsize = sb.st_size;
 141               if (fsize < 0)
 142                 {
 143                   /* Sanity check.  Overflow is the only reason I can think
 144                      this would ever go negative. */
 145                   error (0, 0, _("%s has unusable, apparently negative size"),
 146                          quoteaf (fname));
 147                   return false;
 148                 }
 149             }
 150           else
 151             {
 152               fsize = lseek (fd, 0, SEEK_END);
 153               if (fsize < 0)
 154                 {
 155                   error (0, errno, _("cannot get the size of %s"),
 156                          quoteaf (fname));
 157                   return false;
 158                 }
 159             }
 160         }
 161
 162       if (rel_mode == rm_min)
 163         nsize = MAX (fsize, ssize);
 164       else if (rel_mode == rm_max)
 165         nsize = MIN (fsize, ssize);
 166       else if (rel_mode == rm_rdn)
 167         /* 0..ssize-1 -> 0 */
 168         nsize = fsize - fsize % ssize;
 169       else
 170         {
 171           if (rel_mode == rm_rup)
 172             {
 173               /* 1..ssize -> ssize */
 174               off_t r = fsize % ssize;
 175               ssize = r == 0 ? 0 : ssize - r;
 176             }
 177           if (INT_ADD_WRAPV (fsize, ssize, &nsize))
 178             {
 179               error (0, 0, _("overflow extending size of file %s"),
 180                      quoteaf (fname));
 181               return false;
 182             }
 183         }
 184     }
 185   else
 186     nsize = ssize;
 187   if (nsize < 0)
 188     nsize = 0;
 189
 190   if (ftruncate (fd, nsize) != 0)
 191     {
 192       intmax_t s = nsize;
 193       error (0, errno, _("failed to truncate %s at %"PRIdMAX" bytes"),
 194              quoteaf (fname), s);
 195       return false;
 196     }
 197
 198   return true;
 199 }
 200
 201 int
 202 main (int argc, char **argv)
 203 {
 204   bool got_size = false;
 205   off_t size IF_LINT ( = 0);
 206   off_t rsize = -1;
 207   rel_mode_t rel_mode = rm_abs;
 208   int c;
 209
 210   initialize_main (&argc, &argv);
 211   set_program_name (argv[0]);
 212   setlocale (LC_ALL, "");
 213   bindtextdomain (PACKAGE, LOCALEDIR);
 214   textdomain (PACKAGE);
 215
 216   atexit (close_stdout);
 217
 218   while ((c = getopt_long (argc, argv, "cor:s:", longopts, nullptr)) != -1)
 219     {
 220       switch (c)
 221         {
 222         case 'c':
 223           no_create = true;
 224           break;
 225
 226         case 'o':
 227           block_mode = true;
 228           break;
 229
 230         case 'r':
 231           ref_file = optarg;
 232           break;
 233
 234         case 's':
 235           /* skip any whitespace */
 236           while (isspace (to_uchar (*optarg)))
 237             optarg++;
 238           switch (*optarg)
 239             {
 240             case '<':
 241               rel_mode = rm_max;
 242               optarg++;
 243               break;
 244             case '>':
 245               rel_mode = rm_min;
 246               optarg++;
 247               break;
 248             case '/':
 249               rel_mode = rm_rdn;
 250               optarg++;
 251               break;
 252             case '%':
 253               rel_mode = rm_rup;
 254               optarg++;
 255               break;
 256             }
 257           /* skip any whitespace */
 258           while (isspace (to_uchar (*optarg)))
 259             optarg++;
 260           if (*optarg == '+' || *optarg == '-')
 261             {
 262               if (rel_mode)
 263                 {
 264                   error (0, 0, _("multiple relative modifiers specified"));
 265                   /* Note other combinations are flagged as invalid numbers */
 266                   usage (EXIT_FAILURE);
 267                 }
 268               rel_mode = rm_rel;
 269             }
 270           /* Support dd BLOCK size suffixes + lowercase g,t,m for bsd compat.
 271              Note we don't support dd's b=512, c=1, w=2 or 21x512MiB formats. */
 272           size = xdectoimax (optarg, OFF_T_MIN, OFF_T_MAX, "EgGkKmMPQRtTYZ0",
 273                              _("Invalid number"), 0);
 274           /* Rounding to multiple of 0 is nonsensical */
 275           if ((rel_mode == rm_rup || rel_mode == rm_rdn) && size == 0)
 276             die (EXIT_FAILURE, 0, _("division by zero"));
 277           got_size = true;
 278           break;
 279
 280         case_GETOPT_HELP_CHAR;
 281
 282         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 283
 284         default:
 285           usage (EXIT_FAILURE);
 286         }
 287     }
 288
 289   argv += optind;
 290   argc -= optind;
 291
 292   /* must specify either size or reference file */
 293   if (!ref_file && !got_size)
 294     {
 295       error (0, 0, _("you must specify either %s or %s"),
 296              quote_n (0, "--size"), quote_n (1, "--reference"));
 297       usage (EXIT_FAILURE);
 298     }
 299   /* must specify a relative size with a reference file */
 300   if (ref_file && got_size && !rel_mode)
 301     {
 302       error (0, 0, _("you must specify a relative %s with %s"),
 303              quote_n (0, "--size"), quote_n (1, "--reference"));
 304       usage (EXIT_FAILURE);
 305     }
 306   /* block_mode without size is not valid */
 307   if (block_mode && !got_size)
 308     {
 309       error (0, 0, _("%s was specified but %s was not"),
 310              quote_n (0, "--io-blocks"), quote_n (1, "--size"));
 311       usage (EXIT_FAILURE);
 312     }
 313   /* must specify at least 1 file */
 314   if (argc < 1)
 315     {
 316       error (0, 0, _("missing file operand"));
 317       usage (EXIT_FAILURE);
 318     }
 319
 320   if (ref_file)
 321     {
 322       struct stat sb;
 323       off_t file_size = -1;
 324       if (stat (ref_file, &sb) != 0)
 325         die (EXIT_FAILURE, errno, _("cannot stat %s"), quoteaf (ref_file));
 326       if (usable_st_size (&sb))
 327         file_size = sb.st_size;
 328       else
 329         {
 330           int ref_fd = open (ref_file, O_RDONLY);
 331           if (0 <= ref_fd)
 332             {
 333               off_t file_end = lseek (ref_fd, 0, SEEK_END);
 334               int saved_errno = errno;
 335               close (ref_fd); /* ignore failure */
 336               if (0 <= file_end)
 337                 file_size = file_end;
 338               else
 339                 {
 340                   /* restore, in case close clobbered it. */
 341                   errno = saved_errno;
 342                 }
 343             }
 344         }
 345       if (file_size < 0)
 346         die (EXIT_FAILURE, errno, _("cannot get the size of %s"),
 347              quoteaf (ref_file));
 348       if (!got_size)
 349         size = file_size;
 350       else
 351         rsize = file_size;
 352     }
 353
 354   int oflags = O_WRONLY | (no_create ? 0 : O_CREAT) | O_NONBLOCK;
 355   bool errors = false;
 356
 357   for (char const *fname; (fname = *argv); argv++)
 358     {
 359       int fd = open (fname, oflags, MODE_RW_UGO);
 360       if (fd < 0)
 361         {
 362           /* 'truncate -s0 -c no-such-file'  shouldn't gen error
 363              'truncate -s0 no-such-dir/file' should gen ENOENT error
 364              'truncate -s0 no-such-dir/' should gen EISDIR error
 365              'truncate -s0 .' should gen EISDIR error */
 366           if (!(no_create && errno == ENOENT))
 367             {
 368               error (0, errno, _("cannot open %s for writing"),
 369                      quoteaf (fname));
 370               errors = true;
 371             }
 372         }
 373       else
 374         {
 375           errors |= !do_ftruncate (fd, fname, size, rsize, rel_mode);
 376           if (close (fd) != 0)
 377             {
 378               error (0, errno, _("failed to close %s"), quoteaf (fname));
 379               errors = true;
 380             }
 381         }
 382     }
 383
 384   return errors ? EXIT_FAILURE : EXIT_SUCCESS;
 385 }