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