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