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