Dogcows Code - chaz/tar/blob - src/checkpoint.c

   1 /* Checkpoint management for tar.
   2
   3    Copyright 2007, 2013 Free Software Foundation, Inc.
   4
   5    This file is part of GNU tar.
   6
   7    GNU tar is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    GNU tar is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <system.h>
  21 #include "common.h"
  22 #include "wordsplit.h"
  23 #include <sys/ioctl.h>
  24 #include "fprintftime.h"
  25
  26 enum checkpoint_opcode
  27   {
  28     cop_dot,
  29     cop_bell,
  30     cop_echo,
  31     cop_ttyout,
  32     cop_sleep,
  33     cop_exec,
  34     cop_totals
  35   };
  36
  37 struct checkpoint_action
  38 {
  39   struct checkpoint_action *next;
  40   enum checkpoint_opcode opcode;
  41   union
  42   {
  43     time_t time;
  44     char *command;
  45   } v;
  46 };
  47
  48 /* Checkpointing counter */
  49 static unsigned checkpoint;
  50
  51 /* List of checkpoint actions */
  52 static struct checkpoint_action *checkpoint_action, *checkpoint_action_tail;
  53
  54 static struct checkpoint_action *
  55 alloc_action (enum checkpoint_opcode opcode)
  56 {
  57   struct checkpoint_action *p = xzalloc (sizeof *p);
  58   if (checkpoint_action_tail)
  59     checkpoint_action_tail->next = p;
  60   else
  61     checkpoint_action = p;
  62   checkpoint_action_tail = p;
  63   p->opcode = opcode;
  64   return p;
  65 }
  66
  67 static char *
  68 copy_string_unquote (const char *str)
  69 {
  70   char *output = xstrdup (str);
  71   size_t len = strlen (output);
  72   if ((*output == '"' || *output == '\'')
  73       && output[len-1] == *output)
  74     {
  75       memmove (output, output+1, len-2);
  76       output[len-2] = 0;
  77     }
  78   unquote_string (output);
  79   return output;
  80 }
  81
  82 void
  83 checkpoint_compile_action (const char *str)
  84 {
  85   struct checkpoint_action *act;
  86
  87   if (strcmp (str, ".") == 0 || strcmp (str, "dot") == 0)
  88     alloc_action (cop_dot);
  89   else if (strcmp (str, "bell") == 0)
  90     alloc_action (cop_bell);
  91   else if (strcmp (str, "echo") == 0)
  92     alloc_action (cop_echo);
  93   else if (strncmp (str, "echo=", 5) == 0)
  94     {
  95       act = alloc_action (cop_echo);
  96       act->v.command = copy_string_unquote (str + 5);
  97     }
  98   else if (strncmp (str, "exec=", 5) == 0)
  99     {
 100       act = alloc_action (cop_exec);
 101       act->v.command = copy_string_unquote (str + 5);
 102     }
 103   else if (strncmp (str, "ttyout=", 7) == 0)
 104     {
 105       act = alloc_action (cop_ttyout);
 106       act->v.command = copy_string_unquote (str + 7);
 107     }
 108   else if (strncmp (str, "sleep=", 6) == 0)
 109     {
 110       char *p;
 111       time_t n = strtoul (str+6, &p, 10);
 112       if (*p)
 113         FATAL_ERROR ((0, 0, _("%s: not a valid timeout"), str));
 114       act = alloc_action (cop_sleep);
 115       act->v.time = n;
 116     }
 117   else if (strcmp (str, "totals") == 0)
 118     alloc_action (cop_totals);
 119   else
 120     FATAL_ERROR ((0, 0, _("%s: unknown checkpoint action"), str));
 121 }
 122
 123 void
 124 checkpoint_finish_compile (void)
 125 {
 126   if (checkpoint_option)
 127     {
 128       if (!checkpoint_action)
 129         /* Provide a historical default */
 130         checkpoint_compile_action ("echo");
 131     }
 132   else if (checkpoint_action)
 133     /* Otherwise, set default checkpoint rate */
 134     checkpoint_option = DEFAULT_CHECKPOINT;
 135 }
 136
 137 static char *checkpoint_total_format[] = {
 138   "R",
 139   "W",
 140   "D"
 141 };
 142
 143 static int
 144 getwidth(FILE *fp)
 145 {
 146   struct winsize ws;
 147
 148   ws.ws_col = ws.ws_row = 0;
 149   if ((ioctl (fileno (fp), TIOCGWINSZ, (char *) &ws) < 0) || ws.ws_col == 0)
 150     {
 151       const char *col = getenv ("COLUMNS");
 152       if (col)
 153         return strtol (col, NULL, 10);
 154       else
 155         return 80;
 156     }
 157   return ws.ws_col;
 158 }
 159
 160 static char *
 161 getarg (const char *input, const char ** endp, char **argbuf, size_t *arglen)
 162 {
 163   if (input[0] == '{')
 164     {
 165       char *p = strchr (input + 1, '}');
 166       if (p)
 167         {
 168           size_t n = p - input;
 169           if (n > *arglen)
 170             {
 171               *arglen = n;
 172               *argbuf = xrealloc (*argbuf, *arglen);
 173             }
 174           n--;
 175           memcpy (*argbuf, input + 1, n);
 176           (*argbuf)[n] = 0;
 177           *endp = p + 1;
 178           return *argbuf;
 179         }
 180     }
 181
 182   *endp = input;
 183   return NULL;
 184 }
 185
 186
 187 static void
 188 format_checkpoint_string (FILE *fp, const char *input, bool do_write,
 189                           unsigned cpn)
 190 {
 191   const char *opstr = do_write ? gettext ("write") : gettext ("read");
 192   char uintbuf[UINTMAX_STRSIZE_BOUND];
 193   char *cps = STRINGIFY_BIGINT (cpn, uintbuf);
 194   const char *ip;
 195   size_t len = 0;
 196
 197   static char *argbuf = NULL;
 198   static size_t arglen = 0;
 199   char *arg = NULL;
 200
 201   if (!input)
 202     {
 203       if (do_write)
 204         /* TRANSLATORS: This is a "checkpoint of write operation",
 205          *not* "Writing a checkpoint".
 206          E.g. in Spanish "Punto de comprobaci@'on de escritura",
 207          *not* "Escribiendo un punto de comprobaci@'on" */
 208         input = gettext ("Write checkpoint %u");
 209       else
 210         /* TRANSLATORS: This is a "checkpoint of read operation",
 211          *not* "Reading a checkpoint".
 212          E.g. in Spanish "Punto de comprobaci@'on de lectura",
 213          *not* "Leyendo un punto de comprobaci@'on" */
 214         input = gettext ("Read checkpoint %u");
 215     }
 216
 217   for (ip = input; *ip; ip++)
 218     {
 219       if (*ip == '%')
 220         {
 221           if (*++ip == '{')
 222             {
 223               arg = getarg (ip, &ip, &argbuf, &arglen);
 224               if (!arg)
 225                 {
 226                   fputc ('%', fp);
 227                   fputc (*ip, fp);
 228                   len += 2;
 229                   continue;
 230                 }
 231             }
 232           switch (*ip)
 233             {
 234             case 'u':
 235               fputs (cps, fp);
 236               len += strlen (cps);
 237               break;
 238
 239             case 's':
 240               fputs (opstr, fp);
 241               len += strlen (opstr);
 242               break;
 243
 244             case 'd':
 245               len += fprintf (fp, "%.0f", compute_duration ());
 246               break;
 247
 248             case 'T':
 249               compute_duration ();
 250               len += format_total_stats (fp, checkpoint_total_format, ',', 0);
 251               break;
 252
 253             case 't':
 254               {
 255                 struct timeval tv;
 256                 struct tm *tm;
 257                 char *fmt = arg ? arg : "%c";
 258
 259                 gettimeofday (&tv, NULL);
 260                 tm = localtime (&tv.tv_sec);
 261                 len += fprintftime (fp, fmt, tm, 0, tv.tv_usec * 1000);
 262               }
 263               break;
 264
 265             case '*':
 266               {
 267                 int w = arg ? strtoul (arg, NULL, 10) : getwidth (fp);
 268                 for (; w > len; len++)
 269                   fputc (' ', fp);
 270               }
 271               break;
 272
 273             default:
 274               fputc ('%', fp);
 275               fputc (*ip, fp);
 276               len += 2;
 277               break;
 278             }
 279           arg = NULL;
 280         }
 281       else
 282         {
 283           fputc (*ip, fp);
 284           if (*ip == '\r')
 285             len = 0;
 286           else
 287             len++;
 288         }
 289     }
 290   fflush (fp);
 291 }
 292
 293 static void
 294 run_checkpoint_actions (bool do_write)
 295 {
 296   struct checkpoint_action *p;
 297   FILE *tty = NULL;
 298
 299   for (p = checkpoint_action; p; p = p->next)
 300     {
 301       switch (p->opcode)
 302         {
 303         case cop_dot:
 304           fputc ('.', stdlis);
 305           fflush (stdlis);
 306           break;
 307
 308         case cop_bell:
 309           if (!tty)
 310             tty = fopen ("/dev/tty", "w");
 311           if (tty)
 312             {
 313               fputc ('\a', tty);
 314               fflush (tty);
 315             }
 316           break;
 317
 318         case cop_echo:
 319           fprintf (stderr, "%s: ", program_name);
 320           format_checkpoint_string (stderr, p->v.command, do_write, checkpoint);
 321           fputc ('\n', stderr);
 322           break;
 323
 324         case cop_ttyout:
 325           if (!tty)
 326             tty = fopen ("/dev/tty", "w");
 327           if (tty)
 328             {
 329               format_checkpoint_string (tty, p->v.command, do_write,
 330                                         checkpoint);
 331               fflush (tty);
 332             }
 333           break;
 334
 335         case cop_sleep:
 336           sleep (p->v.time);
 337           break;
 338
 339         case cop_exec:
 340           sys_exec_checkpoint_script (p->v.command,
 341                                       archive_name_cursor[0],
 342                                       checkpoint);
 343           break;
 344
 345         case cop_totals:
 346           compute_duration ();
 347           print_total_stats ();
 348         }
 349     }
 350   if (tty)
 351     fclose (tty);
 352 }
 353
 354 void
 355 checkpoint_run (bool do_write)
 356 {
 357   if (checkpoint_option && !(++checkpoint % checkpoint_option))
 358     run_checkpoint_actions (do_write);
 359 }