src/transform.c

   1 /* This file is part of GNU tar.
   2    Copyright 2006-2008, 2013-2014, 2016-2017 Free Software Foundation,
   3    Inc.
   4
   5    This program is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 3, or (at your option) any later
   8    version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  13    Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License along
  16    with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <system.h>
  19 #include <regex.h>
  20 #include "common.h"
  21
  22 enum transform_type
  23   {
  24     transform_first,
  25     transform_global
  26   };
  27
  28 enum replace_segm_type
  29   {
  30     segm_literal,   /* Literal segment */
  31     segm_backref,   /* Back-reference segment */
  32     segm_case_ctl   /* Case control segment (GNU extension) */
  33   };
  34
  35 enum case_ctl_type
  36   {
  37     ctl_stop,       /* Stop case conversion */
  38     ctl_upcase_next,/* Turn the next character to uppercase */
  39     ctl_locase_next,/* Turn the next character to lowercase */
  40     ctl_upcase,     /* Turn the replacement to uppercase until ctl_stop */
  41     ctl_locase      /* Turn the replacement to lowercase until ctl_stop */
  42   };
  43
  44 struct replace_segm
  45 {
  46   struct replace_segm *next;
  47   enum replace_segm_type type;
  48   union
  49   {
  50     struct
  51     {
  52       char *ptr;
  53       size_t size;
  54     } literal;                /* type == segm_literal */
  55     size_t ref;               /* type == segm_backref */
  56     enum case_ctl_type ctl;   /* type == segm_case_ctl */
  57   } v;
  58 };
  59
  60 struct transform
  61 {
  62   struct transform *next;
  63   enum transform_type transform_type;
  64   int flags;
  65   unsigned match_number;
  66   regex_t regex;
  67   /* Compiled replacement expression */
  68   struct replace_segm *repl_head, *repl_tail;
  69   size_t segm_count; /* Number of elements in the above list */
  70 };
  71
  72 \f
  73
  74 static int transform_flags = XFORM_ALL;
  75 static struct transform *transform_head, *transform_tail;
  76
  77 static struct transform *
  78 new_transform (void)
  79 {
  80   struct transform *p = xzalloc (sizeof *p);
  81   if (transform_tail)
  82     transform_tail->next = p;
  83   else
  84     transform_head = p;
  85   transform_tail = p;
  86   return p;
  87 }
  88
  89 static struct replace_segm *
  90 add_segment (struct transform *tf)
  91 {
  92   struct replace_segm *segm = xmalloc (sizeof *segm);
  93   segm->next = NULL;
  94   if (tf->repl_tail)
  95     tf->repl_tail->next = segm;
  96   else
  97     tf->repl_head = segm;
  98   tf->repl_tail = segm;
  99   tf->segm_count++;
 100   return segm;
 101 }
 102
 103 static void
 104 add_literal_segment (struct transform *tf, char *str, char *end)
 105 {
 106   size_t len = end - str;
 107   if (len)
 108     {
 109       struct replace_segm *segm = add_segment (tf);
 110       segm->type = segm_literal;
 111       segm->v.literal.ptr = xmalloc (len + 1);
 112       memcpy (segm->v.literal.ptr, str, len);
 113       segm->v.literal.ptr[len] = 0;
 114       segm->v.literal.size = len;
 115     }
 116 }
 117
 118 static void
 119 add_char_segment (struct transform *tf, int chr)
 120 {
 121   struct replace_segm *segm = add_segment (tf);
 122   segm->type = segm_literal;
 123   segm->v.literal.ptr = xmalloc (2);
 124   segm->v.literal.ptr[0] = chr;
 125   segm->v.literal.ptr[1] = 0;
 126   segm->v.literal.size = 1;
 127 }
 128
 129 static void
 130 add_backref_segment (struct transform *tf, size_t ref)
 131 {
 132   struct replace_segm *segm = add_segment (tf);
 133   segm->type = segm_backref;
 134   segm->v.ref = ref;
 135 }
 136
 137 static int
 138 parse_xform_flags (int *pflags, int c)
 139 {
 140   switch (c)
 141     {
 142     case 'r':
 143       *pflags |= XFORM_REGFILE;
 144       break;
 145
 146     case 'R':
 147       *pflags &= ~XFORM_REGFILE;
 148       break;
 149
 150     case 'h':
 151       *pflags |= XFORM_LINK;
 152       break;
 153
 154     case 'H':
 155       *pflags &= ~XFORM_LINK;
 156       break;
 157
 158     case 's':
 159       *pflags |= XFORM_SYMLINK;
 160       break;
 161
 162     case 'S':
 163       *pflags &= ~XFORM_SYMLINK;
 164       break;
 165
 166     default:
 167       return 1;
 168     }
 169   return 0;
 170 }
 171
 172 static void
 173 add_case_ctl_segment (struct transform *tf, enum case_ctl_type ctl)
 174 {
 175   struct replace_segm *segm = add_segment (tf);
 176   segm->type = segm_case_ctl;
 177   segm->v.ctl = ctl;
 178 }
 179
 180 static const char *
 181 parse_transform_expr (const char *expr)
 182 {
 183   int delim;
 184   int i, j, rc;
 185   char *str, *beg, *cur;
 186   const char *p;
 187   int cflags = 0;
 188   struct transform *tf = new_transform ();
 189
 190   if (expr[0] != 's')
 191     {
 192       if (strncmp (expr, "flags=", 6) == 0)
 193         {
 194           transform_flags = 0;
 195           for (expr += 6; *expr; expr++)
 196             {
 197               if (*expr == ';')
 198                 {
 199                   expr++;
 200                   break;
 201                 }
 202               if (parse_xform_flags (&transform_flags, *expr))
 203                 USAGE_ERROR ((0, 0, _("Unknown transform flag: %c"),
 204                               *expr));
 205             }
 206           return expr;
 207         }
 208       USAGE_ERROR ((0, 0, _("Invalid transform expression")));
 209     }
 210
 211   delim = expr[1];
 212
 213   /* Scan regular expression */
 214   for (i = 2; expr[i] && expr[i] != delim; i++)
 215     if (expr[i] == '\\' && expr[i+1])
 216       i++;
 217
 218   if (expr[i] != delim)
 219     USAGE_ERROR ((0, 0, _("Invalid transform expression")));
 220
 221   /* Scan replacement expression */
 222   for (j = i + 1; expr[j] && expr[j] != delim; j++)
 223     if (expr[j] == '\\' && expr[j+1])
 224       j++;
 225
 226   if (expr[j] != delim)
 227     USAGE_ERROR ((0, 0, _("Invalid transform expression")));
 228
 229   /* Check flags */
 230   tf->transform_type = transform_first;
 231   tf->flags = transform_flags;
 232   for (p = expr + j + 1; *p && *p != ';'; p++)
 233     switch (*p)
 234       {
 235       case 'g':
 236         tf->transform_type = transform_global;
 237         break;
 238
 239       case 'i':
 240         cflags |= REG_ICASE;
 241         break;
 242
 243       case 'x':
 244         cflags |= REG_EXTENDED;
 245         break;
 246
 247       case '0': case '1': case '2': case '3': case '4':
 248       case '5': case '6': case '7': case '8': case '9':
 249         tf->match_number = strtoul (p, (char**) &p, 0);
 250         p--;
 251         break;
 252
 253       default:
 254         if (parse_xform_flags (&tf->flags, *p))
 255           USAGE_ERROR ((0, 0, _("Unknown flag in transform expression: %c"),
 256                         *p));
 257       }
 258
 259   if (*p == ';')
 260     p++;
 261
 262   /* Extract and compile regex */
 263   str = xmalloc (i - 1);
 264   memcpy (str, expr + 2, i - 2);
 265   str[i - 2] = 0;
 266
 267   rc = regcomp (&tf->regex, str, cflags);
 268
 269   if (rc)
 270     {
 271       char errbuf[512];
 272       regerror (rc, &tf->regex, errbuf, sizeof (errbuf));
 273       USAGE_ERROR ((0, 0, _("Invalid transform expression: %s"), errbuf));
 274     }
 275
 276   if (str[0] == '^' || str[strlen (str) - 1] == '$')
 277     tf->transform_type = transform_first;
 278
 279   free (str);
 280
 281   /* Extract and compile replacement expr */
 282   i++;
 283   str = xmalloc (j - i + 1);
 284   memcpy (str, expr + i, j - i);
 285   str[j - i] = 0;
 286
 287   for (cur = beg = str; *cur;)
 288     {
 289       if (*cur == '\\')
 290         {
 291           size_t n;
 292
 293           add_literal_segment (tf, beg, cur);
 294           switch (*++cur)
 295             {
 296             case '0': case '1': case '2': case '3': case '4':
 297             case '5': case '6': case '7': case '8': case '9':
 298               n = strtoul (cur, &cur, 10);
 299               if (n > tf->regex.re_nsub)
 300                 USAGE_ERROR ((0, 0, _("Invalid transform replacement: back reference out of range")));
 301               add_backref_segment (tf, n);
 302               break;
 303
 304             case '\\':
 305               add_char_segment (tf, '\\');
 306               cur++;
 307               break;
 308
 309             case 'a':
 310               add_char_segment (tf, '\a');
 311               cur++;
 312               break;
 313
 314             case 'b':
 315               add_char_segment (tf, '\b');
 316               cur++;
 317               break;
 318
 319             case 'f':
 320               add_char_segment (tf, '\f');
 321               cur++;
 322               break;
 323
 324             case 'n':
 325               add_char_segment (tf, '\n');
 326               cur++;
 327               break;
 328
 329             case 'r':
 330               add_char_segment (tf, '\r');
 331               cur++;
 332               break;
 333
 334             case 't':
 335               add_char_segment (tf, '\t');
 336               cur++;
 337               break;
 338
 339             case 'v':
 340               add_char_segment (tf, '\v');
 341               cur++;
 342               break;
 343
 344             case '&':
 345               add_char_segment (tf, '&');
 346               cur++;
 347               break;
 348
 349             case 'L':
 350               /* Turn the replacement to lowercase until a '\U' or '\E'
 351                  is found, */
 352               add_case_ctl_segment (tf, ctl_locase);
 353               cur++;
 354               break;
 355
 356             case 'l':
 357               /* Turn the next character to lowercase, */
 358               add_case_ctl_segment (tf, ctl_locase_next);
 359               cur++;
 360               break;
 361
 362             case 'U':
 363               /* Turn the replacement to uppercase until a '\L' or '\E'
 364                  is found, */
 365               add_case_ctl_segment (tf, ctl_upcase);
 366               cur++;
 367               break;
 368
 369             case 'u':
 370               /* Turn the next character to uppercase, */
 371               add_case_ctl_segment (tf, ctl_upcase_next);
 372               cur++;
 373               break;
 374
 375             case 'E':
 376               /* Stop case conversion started by '\L' or '\U'. */
 377               add_case_ctl_segment (tf, ctl_stop);
 378               cur++;
 379               break;
 380
 381             default:
 382               if (*cur == delim)
 383                 add_char_segment (tf, delim);
 384               else
 385                 {
 386                   char buf[2];
 387                   buf[0] = '\\';
 388                   buf[1] = *cur;
 389                   add_literal_segment (tf, buf, buf + 2);
 390                 }
 391               cur++;
 392               break;
 393             }
 394           beg = cur;
 395         }
 396       else if (*cur == '&')
 397         {
 398           add_literal_segment (tf, beg, cur);
 399           add_backref_segment (tf, 0);
 400           beg = ++cur;
 401         }
 402       else
 403         cur++;
 404     }
 405   add_literal_segment (tf, beg, cur);
 406
 407   return p;
 408 }
 409
 410 void
 411 set_transform_expr (const char *expr)
 412 {
 413   while (*expr)
 414     expr = parse_transform_expr (expr);
 415 }
 416
 417 /* Run case conversion specified by CASE_CTL on array PTR of SIZE
 418    characters. Returns pointer to statically allocated storage. */
 419 static char *
 420 run_case_conv (enum case_ctl_type case_ctl, char *ptr, size_t size)
 421 {
 422   static char *case_ctl_buffer;
 423   static size_t case_ctl_bufsize;
 424   char *p;
 425
 426   if (case_ctl_bufsize < size)
 427     {
 428       case_ctl_bufsize = size;
 429       case_ctl_buffer = xrealloc (case_ctl_buffer, case_ctl_bufsize);
 430     }
 431   memcpy (case_ctl_buffer, ptr, size);
 432   switch (case_ctl)
 433     {
 434     case ctl_upcase_next:
 435       case_ctl_buffer[0] = toupper ((unsigned char) case_ctl_buffer[0]);
 436       break;
 437
 438     case ctl_locase_next:
 439       case_ctl_buffer[0] = tolower ((unsigned char) case_ctl_buffer[0]);
 440       break;
 441
 442     case ctl_upcase:
 443       for (p = case_ctl_buffer; p < case_ctl_buffer + size; p++)
 444         *p = toupper ((unsigned char) *p);
 445       break;
 446
 447     case ctl_locase:
 448       for (p = case_ctl_buffer; p < case_ctl_buffer + size; p++)
 449         *p = tolower ((unsigned char) *p);
 450       break;
 451
 452     case ctl_stop:
 453       break;
 454     }
 455   return case_ctl_buffer;
 456 }
 457
 458 \f
 459 static struct obstack stk;
 460 static bool stk_init;
 461
 462 static void
 463 _single_transform_name_to_obstack (struct transform *tf, char *input)
 464 {
 465   regmatch_t *rmp;
 466   int rc;
 467   size_t nmatches = 0;
 468   enum case_ctl_type case_ctl = ctl_stop,  /* Current case conversion op */
 469                      save_ctl = ctl_stop;  /* Saved case_ctl for \u and \l */
 470
 471   /* Reset case conversion after a single-char operation */
 472 #define CASE_CTL_RESET()  if (case_ctl == ctl_upcase_next     \
 473                               || case_ctl == ctl_locase_next) \
 474                             {                                 \
 475                               case_ctl = save_ctl;            \
 476                               save_ctl = ctl_stop;            \
 477                             }
 478
 479   rmp = xmalloc ((tf->regex.re_nsub + 1) * sizeof (*rmp));
 480
 481   while (*input)
 482     {
 483       size_t disp;
 484       char *ptr;
 485
 486       rc = regexec (&tf->regex, input, tf->regex.re_nsub + 1, rmp, 0);
 487
 488       if (rc == 0)
 489         {
 490           struct replace_segm *segm;
 491
 492           disp = rmp[0].rm_eo;
 493
 494           if (rmp[0].rm_so)
 495             obstack_grow (&stk, input, rmp[0].rm_so);
 496
 497           nmatches++;
 498           if (tf->match_number && nmatches < tf->match_number)
 499             {
 500               obstack_grow (&stk, input, disp);
 501               input += disp;
 502               continue;
 503             }
 504
 505           for (segm = tf->repl_head; segm; segm = segm->next)
 506             {
 507               switch (segm->type)
 508                 {
 509                 case segm_literal:    /* Literal segment */
 510                   if (case_ctl == ctl_stop)
 511                     ptr = segm->v.literal.ptr;
 512                   else
 513                     {
 514                       ptr = run_case_conv (case_ctl,
 515                                            segm->v.literal.ptr,
 516                                            segm->v.literal.size);
 517                       CASE_CTL_RESET();
 518                     }
 519                   obstack_grow (&stk, ptr, segm->v.literal.size);
 520                   break;
 521
 522                 case segm_backref:    /* Back-reference segment */
 523                   if (rmp[segm->v.ref].rm_so != -1
 524                       && rmp[segm->v.ref].rm_eo != -1)
 525                     {
 526                       size_t size = rmp[segm->v.ref].rm_eo
 527                                       - rmp[segm->v.ref].rm_so;
 528                       ptr = input + rmp[segm->v.ref].rm_so;
 529                       if (case_ctl != ctl_stop)
 530                         {
 531                           ptr = run_case_conv (case_ctl, ptr, size);
 532                           CASE_CTL_RESET();
 533                         }
 534
 535                       obstack_grow (&stk, ptr, size);
 536                     }
 537                   break;
 538
 539                 case segm_case_ctl:
 540                   switch (segm->v.ctl)
 541                     {
 542                     case ctl_upcase_next:
 543                     case ctl_locase_next:
 544                       switch (save_ctl)
 545                         {
 546                         case ctl_stop:
 547                         case ctl_upcase:
 548                         case ctl_locase:
 549                           save_ctl = case_ctl;
 550                         default:
 551                           break;
 552                         }
 553                       /*FALL THROUGH*/
 554
 555                     case ctl_upcase:
 556                     case ctl_locase:
 557                     case ctl_stop:
 558                       case_ctl = segm->v.ctl;
 559                     }
 560                 }
 561             }
 562         }
 563       else
 564         {
 565           disp = strlen (input);
 566           obstack_grow (&stk, input, disp);
 567         }
 568
 569       input += disp;
 570
 571       if (tf->transform_type == transform_first)
 572         {
 573           obstack_grow (&stk, input, strlen (input));
 574           break;
 575         }
 576     }
 577
 578   obstack_1grow (&stk, 0);
 579   free (rmp);
 580 }
 581
 582 static bool
 583 _transform_name_to_obstack (int flags, char *input, char **output)
 584 {
 585   struct transform *tf;
 586   bool alloced = false;
 587
 588   if (!stk_init)
 589     {
 590       obstack_init (&stk);
 591       stk_init = true;
 592     }
 593
 594   for (tf = transform_head; tf; tf = tf->next)
 595     {
 596       if (tf->flags & flags)
 597         {
 598           _single_transform_name_to_obstack (tf, input);
 599           input = obstack_finish (&stk);
 600           alloced = true;
 601         }
 602     }
 603   *output = input;
 604   return alloced;
 605 }
 606
 607 bool
 608 transform_name_fp (char **pinput, int flags,
 609                    char *(*fun)(char *, void *), void *dat)
 610 {
 611     char *str;
 612     bool ret = _transform_name_to_obstack (flags, *pinput, &str);
 613     if (ret)
 614       {
 615         assign_string (pinput, fun ? fun (str, dat) : str);
 616         obstack_free (&stk, str);
 617       }
 618     else if (fun)
 619       {
 620         *pinput = NULL;
 621         assign_string (pinput, fun (str, dat));
 622         free (str);
 623         ret = true;
 624       }
 625     return ret;
 626 }
 627
 628 bool
 629 transform_name (char **pinput, int type)
 630 {
 631   return transform_name_fp (pinput, type, NULL, NULL);
 632 }
 633
 634 bool
 635 transform_program_p (void)
 636 {
 637   return transform_head != NULL;
 638 }