bin/pax/pat_rep.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1992 Keith Muller.
   5  * Copyright (c) 1992, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Keith Muller of the University of California, San Diego.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <regex.h>
  42 #include "pax.h"
  43 #include "pat_rep.h"
  44 #include "extern.h"
  45
  46 /*
  47  * routines to handle pattern matching, name modification (regular expression
  48  * substitution and interactive renames), and destination name modification for
  49  * copy (-rw). Both file name and link names are adjusted as required in these
  50  * routines.
  51  */
  52
  53 #define MAXSUBEXP       10              /* max subexpressions, DO NOT CHANGE */
  54 static PATTERN *pathead = NULL;         /* file pattern match list head */
  55 static PATTERN *pattail = NULL;         /* file pattern match list tail */
  56 static REPLACE *rephead = NULL;         /* replacement string list head */
  57 static REPLACE *reptail = NULL;         /* replacement string list tail */
  58
  59 static int rep_name(char *, int *, int);
  60 static int tty_rename(ARCHD *);
  61 static int fix_path(char *, int *, char *, int);
  62 static int fn_match(char *, char *, char **);
  63 static char * range_match(char *, int);
  64 static int resub(regex_t *, regmatch_t *, char *, char *, char *, char *);
  65
  66 /*
  67  * rep_add()
  68  *      parses the -s replacement string; compiles the regular expression
  69  *      and stores the compiled value and it's replacement string together in
  70  *      replacement string list. Input to this function is of the form:
  71  *              /old/new/pg
  72  *      The first char in the string specifies the delimiter used by this
  73  *      replacement string. "Old" is a regular expression in "ed" format which
  74  *      is compiled by regcomp() and is applied to filenames. "new" is the
  75  *      substitution string; p and g are options flags for printing and global
  76  *      replacement (over the single filename)
  77  * Return:
  78  *      0 if a proper replacement string and regular expression was added to
  79  *      the list of replacement patterns; -1 otherwise.
  80  */
  81
  82 int
  83 rep_add(char *str)
  84 {
  85         char *pt1;
  86         char *pt2;
  87         REPLACE *rep;
  88         int res;
  89         char rebuf[BUFSIZ];
  90
  91         /*
  92          * throw out the bad parameters
  93          */
  94         if ((str == NULL) || (*str == '\0')) {
  95                 paxwarn(1, "Empty replacement string");
  96                 return(-1);
  97         }
  98
  99         /*
 100          * first character in the string specifies what the delimiter is for
 101          * this expression
 102          */
 103         if ((pt1 = strchr(str+1, *str)) == NULL) {
 104                 paxwarn(1, "Invalid replacement string %s", str);
 105                 return(-1);
 106         }
 107
 108         /*
 109          * allocate space for the node that handles this replacement pattern
 110          * and split out the regular expression and try to compile it
 111          */
 112         if ((rep = (REPLACE *)malloc(sizeof(REPLACE))) == NULL) {
 113                 paxwarn(1, "Unable to allocate memory for replacement string");
 114                 return(-1);
 115         }
 116
 117         *pt1 = '\0';
 118         if ((res = regcomp(&(rep->rcmp), str+1, 0)) != 0) {
 119                 regerror(res, &(rep->rcmp), rebuf, sizeof(rebuf));
 120                 paxwarn(1, "%s while compiling regular expression %s", rebuf, str);
 121                 free(rep);
 122                 return(-1);
 123         }
 124
 125         /*
 126          * put the delimiter back in case we need an error message and
 127          * locate the delimiter at the end of the replacement string
 128          * we then point the node at the new substitution string
 129          */
 130         *pt1++ = *str;
 131         if ((pt2 = strchr(pt1, *str)) == NULL) {
 132                 regfree(&rep->rcmp);
 133                 free(rep);
 134                 paxwarn(1, "Invalid replacement string %s", str);
 135                 return(-1);
 136         }
 137
 138         *pt2 = '\0';
 139         rep->nstr = pt1;
 140         pt1 = pt2++;
 141         rep->flgs = 0;
 142
 143         /*
 144          * set the options if any
 145          */
 146         while (*pt2 != '\0') {
 147                 switch(*pt2) {
 148                 case 'g':
 149                 case 'G':
 150                         rep->flgs  |= GLOB;
 151                         break;
 152                 case 'p':
 153                 case 'P':
 154                         rep->flgs  |= PRNT;
 155                         break;
 156                 default:
 157                         regfree(&rep->rcmp);
 158                         free(rep);
 159                         *pt1 = *str;
 160                         paxwarn(1, "Invalid replacement string option %s", str);
 161                         return(-1);
 162                 }
 163                 ++pt2;
 164         }
 165
 166         /*
 167          * all done, link it in at the end
 168          */
 169         rep->fow = NULL;
 170         if (rephead == NULL) {
 171                 reptail = rephead = rep;
 172                 return(0);
 173         }
 174         reptail->fow = rep;
 175         reptail = rep;
 176         return(0);
 177 }
 178
 179 /*
 180  * pat_add()
 181  *      add a pattern match to the pattern match list. Pattern matches are used
 182  *      to select which archive members are extracted. (They appear as
 183  *      arguments to pax in the list and read modes). If no patterns are
 184  *      supplied to pax, all members in the archive will be selected (and the
 185  *      pattern match list is empty).
 186  * Return:
 187  *      0 if the pattern was added to the list, -1 otherwise
 188  */
 189
 190 int
 191 pat_add(char *str, char *chdnam)
 192 {
 193         PATTERN *pt;
 194
 195         /*
 196          * throw out the junk
 197          */
 198         if ((str == NULL) || (*str == '\0')) {
 199                 paxwarn(1, "Empty pattern string");
 200                 return(-1);
 201         }
 202
 203         /*
 204          * allocate space for the pattern and store the pattern. the pattern is
 205          * part of argv so do not bother to copy it, just point at it. Add the
 206          * node to the end of the pattern list
 207          */
 208         if ((pt = (PATTERN *)malloc(sizeof(PATTERN))) == NULL) {
 209                 paxwarn(1, "Unable to allocate memory for pattern string");
 210                 return(-1);
 211         }
 212
 213         pt->pstr = str;
 214         pt->pend = NULL;
 215         pt->plen = strlen(str);
 216         pt->fow = NULL;
 217         pt->flgs = 0;
 218         pt->chdname = chdnam;
 219
 220         if (pathead == NULL) {
 221                 pattail = pathead = pt;
 222                 return(0);
 223         }
 224         pattail->fow = pt;
 225         pattail = pt;
 226         return(0);
 227 }
 228
 229 /*
 230  * pat_chk()
 231  *      complain if any the user supplied pattern did not result in a match to
 232  *      a selected archive member.
 233  */
 234
 235 void
 236 pat_chk(void)
 237 {
 238         PATTERN *pt;
 239         int wban = 0;
 240
 241         /*
 242          * walk down the list checking the flags to make sure MTCH was set,
 243          * if not complain
 244          */
 245         for (pt = pathead; pt != NULL; pt = pt->fow) {
 246                 if (pt->flgs & MTCH)
 247                         continue;
 248                 if (!wban) {
 249                         paxwarn(1, "WARNING! These patterns were not matched:");
 250                         ++wban;
 251                 }
 252                 (void)fprintf(stderr, "%s\n", pt->pstr);
 253         }
 254 }
 255
 256 /*
 257  * pat_sel()
 258  *      the archive member which matches a pattern was selected. Mark the
 259  *      pattern as having selected an archive member. arcn->pat points at the
 260  *      pattern that was matched. arcn->pat is set in pat_match()
 261  *
 262  *      NOTE: When the -c option is used, we are called when there was no match
 263  *      by pat_match() (that means we did match before the inverted sense of
 264  *      the logic). Now this seems really strange at first, but with -c  we
 265  *      need to keep track of those patterns that cause an archive member to NOT
 266  *      be selected (it found an archive member with a specified pattern)
 267  * Return:
 268  *      0 if the pattern pointed at by arcn->pat was tagged as creating a
 269  *      match, -1 otherwise.
 270  */
 271
 272 int
 273 pat_sel(ARCHD *arcn)
 274 {
 275         PATTERN *pt;
 276         PATTERN **ppt;
 277         int len;
 278
 279         /*
 280          * if no patterns just return
 281          */
 282         if ((pathead == NULL) || ((pt = arcn->pat) == NULL))
 283                 return(0);
 284
 285         /*
 286          * when we are NOT limited to a single match per pattern mark the
 287          * pattern and return
 288          */
 289         if (!nflag) {
 290                 pt->flgs |= MTCH;
 291                 return(0);
 292         }
 293
 294         /*
 295          * we reach this point only when we allow a single selected match per
 296          * pattern, if the pattern matches a directory and we do not have -d
 297          * (dflag) we are done with this pattern. We may also be handed a file
 298          * in the subtree of a directory. in that case when we are operating
 299          * with -d, this pattern was already selected and we are done
 300          */
 301         if (pt->flgs & DIR_MTCH)
 302                 return(0);
 303
 304         if (!dflag && ((pt->pend != NULL) || (arcn->type == PAX_DIR))) {
 305                 /*
 306                  * ok we matched a directory and we are allowing
 307                  * subtree matches but because of the -n only its children will
 308                  * match. This is tagged as a DIR_MTCH type.
 309                  * WATCH IT, the code assumes that pt->pend points
 310                  * into arcn->name and arcn->name has not been modified.
 311                  * If not we will have a big mess. Yup this is another kludge
 312                  */
 313
 314                 /*
 315                  * if this was a prefix match, remove trailing part of path
 316                  * so we can copy it. Future matches will be exact prefix match
 317                  */
 318                 if (pt->pend != NULL)
 319                         *pt->pend = '\0';
 320
 321                 if ((pt->pstr = strdup(arcn->name)) == NULL) {
 322                         paxwarn(1, "Pattern select out of memory");
 323                         if (pt->pend != NULL)
 324                                 *pt->pend = '/';
 325                         pt->pend = NULL;
 326                         return(-1);
 327                 }
 328
 329                 /*
 330                  * put the trailing / back in the source string
 331                  */
 332                 if (pt->pend != NULL) {
 333                         *pt->pend = '/';
 334                         pt->pend = NULL;
 335                 }
 336                 pt->plen = strlen(pt->pstr);
 337
 338                 /*
 339                  * strip off any trailing /, this should really never happen
 340                  */
 341                 len = pt->plen - 1;
 342                 if (*(pt->pstr + len) == '/') {
 343                         *(pt->pstr + len) = '\0';
 344                         pt->plen = len;
 345                 }
 346                 pt->flgs = DIR_MTCH | MTCH;
 347                 arcn->pat = pt;
 348                 return(0);
 349         }
 350
 351         /*
 352          * we are then done with this pattern, so we delete it from the list
 353          * because it can never be used for another match.
 354          * Seems kind of strange to do for a -c, but the pax spec is really
 355          * vague on the interaction of -c -n and -d. We assume that when -c
 356          * and the pattern rejects a member (i.e. it matched it) it is done.
 357          * In effect we place the order of the flags as having -c last.
 358          */
 359         pt = pathead;
 360         ppt = &pathead;
 361         while ((pt != NULL) && (pt != arcn->pat)) {
 362                 ppt = &(pt->fow);
 363                 pt = pt->fow;
 364         }
 365
 366         if (pt == NULL) {
 367                 /*
 368                  * should never happen....
 369                  */
 370                 paxwarn(1, "Pattern list inconsistent");
 371                 return(-1);
 372         }
 373         *ppt = pt->fow;
 374         free(pt);
 375         arcn->pat = NULL;
 376         return(0);
 377 }
 378
 379 /*
 380  * pat_match()
 381  *      see if this archive member matches any supplied pattern, if a match
 382  *      is found, arcn->pat is set to point at the potential pattern. Later if
 383  *      this archive member is "selected" we process and mark the pattern as
 384  *      one which matched a selected archive member (see pat_sel())
 385  * Return:
 386  *      0 if this archive member should be processed, 1 if it should be
 387  *      skipped and -1 if we are done with all patterns (and pax should quit
 388  *      looking for more members)
 389  */
 390
 391 int
 392 pat_match(ARCHD *arcn)
 393 {
 394         PATTERN *pt;
 395
 396         arcn->pat = NULL;
 397
 398         /*
 399          * if there are no more patterns and we have -n (and not -c) we are
 400          * done. otherwise with no patterns to match, matches all
 401          */
 402         if (pathead == NULL) {
 403                 if (nflag && !cflag)
 404                         return(-1);
 405                 return(0);
 406         }
 407
 408         /*
 409          * have to search down the list one at a time looking for a match.
 410          */
 411         pt = pathead;
 412         while (pt != NULL) {
 413                 /*
 414                  * check for a file name match unless we have DIR_MTCH set in
 415                  * this pattern then we want a prefix match
 416                  */
 417                 if (pt->flgs & DIR_MTCH) {
 418                         /*
 419                          * this pattern was matched before to a directory
 420                          * as we must have -n set for this (but not -d). We can
 421                          * only match CHILDREN of that directory so we must use
 422                          * an exact prefix match (no wildcards).
 423                          */
 424                         if ((arcn->name[pt->plen] == '/') &&
 425                             (strncmp(pt->pstr, arcn->name, pt->plen) == 0))
 426                                 break;
 427                 } else if (fn_match(pt->pstr, arcn->name, &pt->pend) == 0)
 428                         break;
 429                 pt = pt->fow;
 430         }
 431
 432         /*
 433          * return the result, remember that cflag (-c) inverts the sense of a
 434          * match
 435          */
 436         if (pt == NULL)
 437                 return(cflag ? 0 : 1);
 438
 439         /*
 440          * We had a match, now when we invert the sense (-c) we reject this
 441          * member. However we have to tag the pattern a being successful, (in a
 442          * match, not in selecting an archive member) so we call pat_sel() here.
 443          */
 444         arcn->pat = pt;
 445         if (!cflag)
 446                 return(0);
 447
 448         if (pat_sel(arcn) < 0)
 449                 return(-1);
 450         arcn->pat = NULL;
 451         return(1);
 452 }
 453
 454 /*
 455  * fn_match()
 456  * Return:
 457  *      0 if this archive member should be processed, 1 if it should be
 458  *      skipped and -1 if we are done with all patterns (and pax should quit
 459  *      looking for more members)
 460  *      Note: *pend may be changed to show where the prefix ends.
 461  */
 462
 463 static int
 464 fn_match(char *pattern, char *string, char **pend)
 465 {
 466         char c;
 467         char test;
 468
 469         *pend = NULL;
 470         for (;;) {
 471                 switch (c = *pattern++) {
 472                 case '\0':
 473                         /*
 474                          * Ok we found an exact match
 475                          */
 476                         if (*string == '\0')
 477                                 return(0);
 478
 479                         /*
 480                          * Check if it is a prefix match
 481                          */
 482                         if ((dflag == 1) || (*string != '/'))
 483                                 return(-1);
 484
 485                         /*
 486                          * It is a prefix match, remember where the trailing
 487                          * / is located
 488                          */
 489                         *pend = string;
 490                         return(0);
 491                 case '?':
 492                         if ((test = *string++) == '\0')
 493                                 return (-1);
 494                         break;
 495                 case '*':
 496                         c = *pattern;
 497                         /*
 498                          * Collapse multiple *'s.
 499                          */
 500                         while (c == '*')
 501                                 c = *++pattern;
 502
 503                         /*
 504                          * Optimized hack for pattern with a * at the end
 505                          */
 506                         if (c == '\0')
 507                                 return (0);
 508
 509                         /*
 510                          * General case, use recursion.
 511                          */
 512                         while ((test = *string) != '\0') {
 513                                 if (!fn_match(pattern, string, pend))
 514                                         return (0);
 515                                 ++string;
 516                         }
 517                         return (-1);
 518                 case '[':
 519                         /*
 520                          * range match
 521                          */
 522                         if (((test = *string++) == '\0') ||
 523                             ((pattern = range_match(pattern, test)) == NULL))
 524                                 return (-1);
 525                         break;
 526                 case '\\':
 527                 default:
 528                         if (c != *string++)
 529                                 return (-1);
 530                         break;
 531                 }
 532         }
 533         /* NOTREACHED */
 534 }
 535
 536 static char *
 537 range_match(char *pattern, int test)
 538 {
 539         char c;
 540         char c2;
 541         int negate;
 542         int ok = 0;
 543
 544         if ((negate = (*pattern == '!')) != 0)
 545                 ++pattern;
 546
 547         while ((c = *pattern++) != ']') {
 548                 /*
 549                  * Illegal pattern
 550                  */
 551                 if (c == '\0')
 552                         return (NULL);
 553
 554                 if ((*pattern == '-') && ((c2 = pattern[1]) != '\0') &&
 555                     (c2 != ']')) {
 556                         if ((c <= test) && (test <= c2))
 557                                 ok = 1;
 558                         pattern += 2;
 559                 } else if (c == test)
 560                         ok = 1;
 561         }
 562         return (ok == negate ? NULL : pattern);
 563 }
 564
 565 /*
 566  * mod_name()
 567  *      modify a selected file name. first attempt to apply replacement string
 568  *      expressions, then apply interactive file rename. We apply replacement
 569  *      string expressions to both filenames and file links (if we didn't the
 570  *      links would point to the wrong place, and we could never be able to
 571  *      move an archive that has a file link in it). When we rename files
 572  *      interactively, we store that mapping (old name to user input name) so
 573  *      if we spot any file links to the old file name in the future, we will
 574  *      know exactly how to fix the file link.
 575  * Return:
 576  *      0 continue to  process file, 1 skip this file, -1 pax is finished
 577  */
 578
 579 int
 580 mod_name(ARCHD *arcn)
 581 {
 582         int res = 0;
 583
 584         /*
 585          * Strip off leading '/' if appropriate.
 586          * Currently, this option is only set for the tar format.
 587          */
 588         if (rmleadslash && arcn->name[0] == '/') {
 589                 if (arcn->name[1] == '\0') {
 590                         arcn->name[0] = '.';
 591                 } else {
 592                         (void)memmove(arcn->name, &arcn->name[1],
 593                             strlen(arcn->name));
 594                         arcn->nlen--;
 595                 }
 596                 if (rmleadslash < 2) {
 597                         rmleadslash = 2;
 598                         paxwarn(0, "Removing leading / from absolute path names in the archive");
 599                 }
 600         }
 601         if (rmleadslash && arcn->ln_name[0] == '/' &&
 602             (arcn->type == PAX_HLK || arcn->type == PAX_HRG)) {
 603                 if (arcn->ln_name[1] == '\0') {
 604                         arcn->ln_name[0] = '.';
 605                 } else {
 606                         (void)memmove(arcn->ln_name, &arcn->ln_name[1],
 607                             strlen(arcn->ln_name));
 608                         arcn->ln_nlen--;
 609                 }
 610                 if (rmleadslash < 2) {
 611                         rmleadslash = 2;
 612                         paxwarn(0, "Removing leading / from absolute path names in the archive");
 613                 }
 614         }
 615
 616         /*
 617          * IMPORTANT: We have a problem. what do we do with symlinks?
 618          * Modifying a hard link name makes sense, as we know the file it
 619          * points at should have been seen already in the archive (and if it
 620          * wasn't seen because of a read error or a bad archive, we lose
 621          * anyway). But there are no such requirements for symlinks. On one
 622          * hand the symlink that refers to a file in the archive will have to
 623          * be modified to so it will still work at its new location in the
 624          * file system. On the other hand a symlink that points elsewhere (and
 625          * should continue to do so) should not be modified. There is clearly
 626          * no perfect solution here. So we handle them like hardlinks. Clearly
 627          * a replacement made by the interactive rename mapping is very likely
 628          * to be correct since it applies to a single file and is an exact
 629          * match. The regular expression replacements are a little harder to
 630          * justify though. We claim that the symlink name is only likely
 631          * to be replaced when it points within the file tree being moved and
 632          * in that case it should be modified. what we really need to do is to
 633          * call an oracle here. :)
 634          */
 635         if (rephead != NULL) {
 636                 /*
 637                  * we have replacement strings, modify the name and the link
 638                  * name if any.
 639                  */
 640                 if ((res = rep_name(arcn->name, &(arcn->nlen), 1)) != 0)
 641                         return(res);
 642
 643                 if (((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) ||
 644                     (arcn->type == PAX_HRG)) &&
 645                     ((res = rep_name(arcn->ln_name, &(arcn->ln_nlen), 0)) != 0))
 646                         return(res);
 647         }
 648
 649         if (iflag) {
 650                 /*
 651                  * perform interactive file rename, then map the link if any
 652                  */
 653                 if ((res = tty_rename(arcn)) != 0)
 654                         return(res);
 655                 if ((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) ||
 656                     (arcn->type == PAX_HRG))
 657                         sub_name(arcn->ln_name, &(arcn->ln_nlen), sizeof(arcn->ln_name));
 658         }
 659         return(res);
 660 }
 661
 662 /*
 663  * tty_rename()
 664  *      Prompt the user for a replacement file name. A "." keeps the old name,
 665  *      a empty line skips the file, and an EOF on reading the tty, will cause
 666  *      pax to stop processing and exit. Otherwise the file name input, replaces
 667  *      the old one.
 668  * Return:
 669  *      0 process this file, 1 skip this file, -1 we need to exit pax
 670  */
 671
 672 static int
 673 tty_rename(ARCHD *arcn)
 674 {
 675         char tmpname[PAXPATHLEN+2];
 676         int res;
 677
 678         /*
 679          * prompt user for the replacement name for a file, keep trying until
 680          * we get some reasonable input. Archives may have more than one file
 681          * on them with the same name (from updates etc). We print verbose info
 682          * on the file so the user knows what is up.
 683          */
 684         tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0);
 685
 686         for (;;) {
 687                 ls_tty(arcn);
 688                 tty_prnt("Input new name, or a \".\" to keep the old name, ");
 689                 tty_prnt("or a \"return\" to skip this file.\n");
 690                 tty_prnt("Input > ");
 691                 if (tty_read(tmpname, sizeof(tmpname)) < 0)
 692                         return(-1);
 693                 if (strcmp(tmpname, "..") == 0) {
 694                         tty_prnt("Try again, illegal file name: ..\n");
 695                         continue;
 696                 }
 697                 if (strlen(tmpname) > PAXPATHLEN) {
 698                         tty_prnt("Try again, file name too long\n");
 699                         continue;
 700                 }
 701                 break;
 702         }
 703
 704         /*
 705          * empty file name, skips this file. a "." leaves it alone
 706          */
 707         if (tmpname[0] == '\0') {
 708                 tty_prnt("Skipping file.\n");
 709                 return(1);
 710         }
 711         if ((tmpname[0] == '.') && (tmpname[1] == '\0')) {
 712                 tty_prnt("Processing continues, name unchanged.\n");
 713                 return(0);
 714         }
 715
 716         /*
 717          * ok the name changed. We may run into links that point at this
 718          * file later. we have to remember where the user sent the file
 719          * in order to repair any links.
 720          */
 721         tty_prnt("Processing continues, name changed to: %s\n", tmpname);
 722         res = add_name(arcn->name, arcn->nlen, tmpname);
 723         arcn->nlen = l_strncpy(arcn->name, tmpname, sizeof(arcn->name) - 1);
 724         arcn->name[arcn->nlen] = '\0';
 725         if (res < 0)
 726                 return(-1);
 727         return(0);
 728 }
 729
 730 /*
 731  * set_dest()
 732  *      fix up the file name and the link name (if any) so this file will land
 733  *      in the destination directory (used during copy() -rw).
 734  * Return:
 735  *      0 if ok, -1 if failure (name too long)
 736  */
 737
 738 int
 739 set_dest(ARCHD *arcn, char *dest_dir, int dir_len)
 740 {
 741         if (fix_path(arcn->name, &(arcn->nlen), dest_dir, dir_len) < 0)
 742                 return(-1);
 743
 744         /*
 745          * It is really hard to deal with symlinks here, we cannot be sure
 746          * if the name they point was moved (or will be moved). It is best to
 747          * leave them alone.
 748          */
 749         if ((arcn->type != PAX_HLK) && (arcn->type != PAX_HRG))
 750                 return(0);
 751
 752         if (fix_path(arcn->ln_name, &(arcn->ln_nlen), dest_dir, dir_len) < 0)
 753                 return(-1);
 754         return(0);
 755 }
 756
 757 /*
 758  * fix_path
 759  *      concatenate dir_name and or_name and store the result in or_name (if
 760  *      it fits). This is one ugly function.
 761  * Return:
 762  *      0 if ok, -1 if the final name is too long
 763  */
 764
 765 static int
 766 fix_path( char *or_name, int *or_len, char *dir_name, int dir_len)
 767 {
 768         char *src;
 769         char *dest;
 770         char *start;
 771         int len;
 772
 773         /*
 774          * we shift the or_name to the right enough to tack in the dir_name
 775          * at the front. We make sure we have enough space for it all before
 776          * we start. since dest always ends in a slash, we skip of or_name
 777          * if it also starts with one.
 778          */
 779         start = or_name;
 780         src = start + *or_len;
 781         dest = src + dir_len;
 782         if (*start == '/') {
 783                 ++start;
 784                 --dest;
 785         }
 786         if ((len = dest - or_name) > PAXPATHLEN) {
 787                 paxwarn(1, "File name %s/%s, too long", dir_name, start);
 788                 return(-1);
 789         }
 790         *or_len = len;
 791
 792         /*
 793          * enough space, shift
 794          */
 795         while (src >= start)
 796                 *dest-- = *src--;
 797         src = dir_name + dir_len - 1;
 798
 799         /*
 800          * splice in the destination directory name
 801          */
 802         while (src >= dir_name)
 803                 *dest-- = *src--;
 804
 805         *(or_name + len) = '\0';
 806         return(0);
 807 }
 808
 809 /*
 810  * rep_name()
 811  *      walk down the list of replacement strings applying each one in order.
 812  *      when we find one with a successful substitution, we modify the name
 813  *      as specified. if required, we print the results. if the resulting name
 814  *      is empty, we will skip this archive member. We use the regexp(3)
 815  *      routines (regexp() ought to win a prize as having the most cryptic
 816  *      library function manual page).
 817  *      --Parameters--
 818  *      name is the file name we are going to apply the regular expressions to
 819  *      (and may be modified)
 820  *      nlen is the length of this name (and is modified to hold the length of
 821  *      the final string).
 822  *      prnt is a flag that says whether to print the final result.
 823  * Return:
 824  *      0 if substitution was successful, 1 if we are to skip the file (the name
 825  *      ended up empty)
 826  */
 827
 828 static int
 829 rep_name(char *name, int *nlen, int prnt)
 830 {
 831         REPLACE *pt;
 832         char *inpt;
 833         char *outpt;
 834         char *endpt;
 835         char *rpt;
 836         int found = 0;
 837         int res;
 838         regmatch_t pm[MAXSUBEXP];
 839         char nname[PAXPATHLEN+1];       /* final result of all replacements */
 840         char buf1[PAXPATHLEN+1];        /* where we work on the name */
 841
 842         /*
 843          * copy the name into buf1, where we will work on it. We need to keep
 844          * the orig string around so we can print out the result of the final
 845          * replacement. We build up the final result in nname. inpt points at
 846          * the string we apply the regular expression to. prnt is used to
 847          * suppress printing when we handle replacements on the link field
 848          * (the user already saw that substitution go by)
 849          */
 850         pt = rephead;
 851         (void)strlcpy(buf1, name, sizeof(buf1));
 852         inpt = buf1;
 853         outpt = nname;
 854         endpt = outpt + PAXPATHLEN;
 855
 856         /*
 857          * try each replacement string in order
 858          */
 859         while (pt != NULL) {
 860                 do {
 861                         /*
 862                          * check for a successful substitution, if not go to
 863                          * the next pattern, or cleanup if we were global
 864                          */
 865                         if (regexec(&(pt->rcmp), inpt, MAXSUBEXP, pm, 0) != 0)
 866                                 break;
 867
 868                         /*
 869                          * ok we found one. We have three parts, the prefix
 870                          * which did not match, the section that did and the
 871                          * tail (that also did not match). Copy the prefix to
 872                          * the final output buffer (watching to make sure we
 873                          * do not create a string too long).
 874                          */
 875                         found = 1;
 876                         rpt = inpt + pm[0].rm_so;
 877
 878                         while ((inpt < rpt) && (outpt < endpt))
 879                                 *outpt++ = *inpt++;
 880                         if (outpt == endpt)
 881                                 break;
 882
 883                         /*
 884                          * for the second part (which matched the regular
 885                          * expression) apply the substitution using the
 886                          * replacement string and place it the prefix in the
 887                          * final output. If we have problems, skip it.
 888                          */
 889                         if ((res = resub(&(pt->rcmp),pm,inpt,pt->nstr,outpt,endpt))
 890                             < 0) {
 891                                 if (prnt)
 892                                         paxwarn(1, "Replacement name error %s",
 893                                             name);
 894                                 return(1);
 895                         }
 896                         outpt += res;
 897
 898                         /*
 899                          * we set up to look again starting at the first
 900                          * character in the tail (of the input string right
 901                          * after the last character matched by the regular
 902                          * expression (inpt always points at the first char in
 903                          * the string to process). If we are not doing a global
 904                          * substitution, we will use inpt to copy the tail to
 905                          * the final result. Make sure we do not overrun the
 906                          * output buffer
 907                          */
 908                         inpt += pm[0].rm_eo - pm[0].rm_so;
 909
 910                         if ((outpt == endpt) || (*inpt == '\0'))
 911                                 break;
 912
 913                         /*
 914                          * if the user wants global we keep trying to
 915                          * substitute until it fails, then we are done.
 916                          */
 917                 } while (pt->flgs & GLOB);
 918
 919                 if (found)
 920                         break;
 921
 922                 /*
 923                  * a successful substitution did NOT occur, try the next one
 924                  */
 925                 pt = pt->fow;
 926         }
 927
 928         if (found) {
 929                 /*
 930                  * we had a substitution, copy the last tail piece (if there is
 931                  * room) to the final result
 932                  */
 933                 while ((outpt < endpt) && (*inpt != '\0'))
 934                         *outpt++ = *inpt++;
 935
 936                 *outpt = '\0';
 937                 if ((outpt == endpt) && (*inpt != '\0')) {
 938                         if (prnt)
 939                                 paxwarn(1,"Replacement name too long %s >> %s",
 940                                     name, nname);
 941                         return(1);
 942                 }
 943
 944                 /*
 945                  * inform the user of the result if wanted
 946                  */
 947                 if (prnt && (pt->flgs & PRNT)) {
 948                         if (*nname == '\0')
 949                                 (void)fprintf(stderr,"%s >> <empty string>\n",
 950                                     name);
 951                         else
 952                                 (void)fprintf(stderr,"%s >> %s\n", name, nname);
 953                 }
 954
 955                 /*
 956                  * if empty inform the caller this file is to be skipped
 957                  * otherwise copy the new name over the orig name and return
 958                  */
 959                 if (*nname == '\0')
 960                         return(1);
 961                 *nlen = l_strncpy(name, nname, PAXPATHLEN + 1);
 962                 name[PAXPATHLEN] = '\0';
 963         }
 964         return(0);
 965 }
 966
 967
 968 /*
 969  * resub()
 970  *      apply the replacement to the matched expression. expand out the old
 971  *      style ed(1) subexpression expansion.
 972  * Return:
 973  *      -1 if error, or the number of characters added to the destination.
 974  */
 975
 976 static int
 977 resub(regex_t *rp, regmatch_t *pm, char *orig, char *src, char *dest,
 978         char *destend)
 979 {
 980         char *spt;
 981         char *dpt;
 982         char c;
 983         regmatch_t *pmpt;
 984         int len;
 985         int subexcnt;
 986
 987         spt =  src;
 988         dpt = dest;
 989         subexcnt = rp->re_nsub;
 990         while ((dpt < destend) && ((c = *spt++) != '\0')) {
 991                 /*
 992                  * see if we just have an ordinary replacement character
 993                  * or we refer to a subexpression.
 994                  */
 995                 if (c == '&') {
 996                         pmpt = pm;
 997                 } else if ((c == '\\') && (*spt >= '0') && (*spt <= '9')) {
 998                         /*
 999                          * make sure there is a subexpression as specified
1000                          */
1001                         if ((len = *spt++ - '0') > subexcnt)
1002                                 return(-1);
1003                         pmpt = pm + len;
1004                 } else {
1005                         /*
1006                          * Ordinary character, just copy it
1007                          */
1008                         if ((c == '\\') && ((*spt == '\\') || (*spt == '&')))
1009                                 c = *spt++;
1010                         *dpt++ = c;
1011                         continue;
1012                 }
1013
1014                 /*
1015                  * continue if the subexpression is bogus
1016                  */
1017                 if ((pmpt->rm_so < 0) || (pmpt->rm_eo < 0) ||
1018                     ((len = pmpt->rm_eo - pmpt->rm_so) <= 0))
1019                         continue;
1020
1021                 /*
1022                  * copy the subexpression to the destination.
1023                  * fail if we run out of space or the match string is damaged
1024                  */
1025                 if (len > (destend - dpt))
1026                         len = destend - dpt;
1027                 if (l_strncpy(dpt, orig + pmpt->rm_so, len) != len)
1028                         return(-1);
1029                 dpt += len;
1030         }
1031         return(dpt - dest);
1032 }