src/transform.c

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