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#ifndef lint 38#if 0 39static const char sccsid[] = "@(#)pat_rep.c 8.2 (Berkeley) 4/18/94"; 40#else 41static const char rcsid[] = "$OpenBSD: pat_rep.c,v 1.30 2005/08/05 08:30:10 djm Exp $"; 42#endif 43#endif /* not lint */ 44 45#include <sys/types.h> 46#include <sys/time.h> 47#include <sys/stat.h> 48#include <sys/param.h> 49#include <stdio.h> 50#include <string.h> 51#include <unistd.h> 52#include <stdlib.h> 53#include <errno.h> 54#include <regex.h> 55#include "pax.h" 56#include "pat_rep.h" 57#include "extern.h" 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 */ 67static PATTERN *pathead = NULL; /* file pattern match list head */ 68static PATTERN *pattail = NULL; /* file pattern match list tail */ 69static REPLACE *rephead = NULL; /* replacement string list head */ 70static REPLACE *reptail = NULL; /* replacement string list tail */ 71 72static int rep_name(char *, size_t, int *, int); 73int tty_rename(ARCHD *); 74static int fix_path(char *, int *, char *, int); 75static int fn_match(char *, char *, char **); 76static char * range_match(char *, int); 77static 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 95int 96rep_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 = (REPLACE *)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 (void)free((char *)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 (void)free((char *)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 (void)free((char *)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 219int 220pat_add(char *str, char *chdname) 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 = (PATTERN *)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 = chdname; 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 264void 265pat_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 301int 302pat_sel(ARCHD *arcn) 303{ 304 PATTERN *pt; 305 PATTERN **ppt; 306 int 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 (void)free((char *)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 420int 421pat_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 an 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 492static int 493fn_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 ((*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 ((*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 565static char * 566range_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 * mod_name() 596 * modify a selected file name. first attempt to apply replacement string 597 * expressions, then apply interactive file rename. We apply replacement 598 * string expressions to both filenames and file links (if we didn't the 599 * links would point to the wrong place, and we could never be able to 600 * move an archive that has a file link in it). When we rename files 601 * interactively, we store that mapping (old name to user input name) so 602 * if we spot any file links to the old file name in the future, we will 603 * know exactly how to fix the file link. 604 * Return: 605 * 0 continue to process file, 1 skip this file, -1 pax is finished 606 */ 607 608int 609mod_name(ARCHD *arcn) 610{ 611 int res = 0; 612 613 /* 614 * Strip off leading '/' if appropriate. 615 * Currently, this option is only set for the tar format. 616 */ 617 while (rmleadslash && arcn->name[0] == '/') { 618 if (arcn->name[1] == '\0') { 619 arcn->name[0] = '.'; 620 } else { 621 (void)memmove(arcn->name, &arcn->name[1], 622 strlen(arcn->name)); 623 arcn->nlen--; 624 } 625 if (rmleadslash < 2) { 626 rmleadslash = 2; 627 paxwarn(0, "Removing leading / from absolute path names in the archive"); 628 } 629 } 630 while (rmleadslash && arcn->ln_name[0] == '/' && 631 (arcn->type == PAX_HLK || arcn->type == PAX_HRG)) { 632 if (arcn->ln_name[1] == '\0') { 633 arcn->ln_name[0] = '.'; 634 } else { 635 (void)memmove(arcn->ln_name, &arcn->ln_name[1], 636 strlen(arcn->ln_name)); 637 arcn->ln_nlen--; 638 } 639 if (rmleadslash < 2) { 640 rmleadslash = 2; 641 paxwarn(0, "Removing leading / from absolute path names in the archive"); 642 } 643 } 644 645 /* 646 * IMPORTANT: We have a problem. what do we do with symlinks? 647 * Modifying a hard link name makes sense, as we know the file it 648 * points at should have been seen already in the archive (and if it 649 * wasn't seen because of a read error or a bad archive, we lose 650 * anyway). But there are no such requirements for symlinks. On one 651 * hand the symlink that refers to a file in the archive will have to 652 * be modified to so it will still work at its new location in the 653 * file system. On the other hand a symlink that points elsewhere (and 654 * should continue to do so) should not be modified. There is clearly 655 * no perfect solution here. So we handle them like hardlinks. Clearly 656 * a replacement made by the interactive rename mapping is very likely 657 * to be correct since it applies to a single file and is an exact 658 * match. The regular expression replacements are a little harder to 659 * justify though. We claim that the symlink name is only likely 660 * to be replaced when it points within the file tree being moved and 661 * in that case it should be modified. what we really need to do is to 662 * call an oracle here. :) 663 */ 664 if (rephead != NULL) { 665 /* 666 * we have replacement strings, modify the name and the link 667 * name if any. 668 */ 669 if ((res = rep_name(arcn->name, sizeof(arcn->name), &(arcn->nlen), 1)) != 0) 670 return(res); 671 672 if (((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) || 673 (arcn->type == PAX_HRG)) && 674 ((res = rep_name(arcn->ln_name, sizeof(arcn->ln_name), &(arcn->ln_nlen), 0)) != 0)) 675 return(res); 676 } 677 678 if (iflag) { 679 /* 680 * perform interactive file rename, then map the link if any 681 */ 682 if ((res = tty_rename(arcn)) != 0) 683 return(res); 684 if ((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) || 685 (arcn->type == PAX_HRG)) 686 sub_name(arcn->ln_name, &(arcn->ln_nlen), sizeof(arcn->ln_name)); 687 } 688 return(res); 689} 690 691/* 692 * tty_rename() 693 * Prompt the user for a replacement file name. A "." keeps the old name, 694 * a empty line skips the file, and an EOF on reading the tty, will cause 695 * pax to stop processing and exit. Otherwise the file name input, replaces 696 * the old one. 697 * Return: 698 * 0 process this file, 1 skip this file, -1 we need to exit pax 699 */ 700 701int 702tty_rename(ARCHD *arcn) 703{ 704 char tmpname[PAXPATHLEN+2]; 705 int res; 706 707 /* 708 * prompt user for the replacement name for a file, keep trying until 709 * we get some reasonable input. Archives may have more than one file 710 * on them with the same name (from updates etc). We print verbose info 711 * on the file so the user knows what is up. 712 */ 713 tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0); 714 715 for (;;) { 716 ls_tty(arcn); 717 tty_prnt("Input new name, or a \".\" to keep the old name, "); 718 tty_prnt("or a \"return\" to skip this file.\n"); 719 tty_prnt("Input > "); 720 if (tty_read(tmpname, sizeof(tmpname)) < 0) 721 return(-1); 722 if (strcmp(tmpname, "..") == 0) { 723 tty_prnt("Try again, illegal file name: ..\n"); 724 continue; 725 } 726 if (strlen(tmpname) > PAXPATHLEN) { 727 tty_prnt("Try again, file name too long\n"); 728 continue; 729 } 730 break; 731 } 732 733 /* 734 * empty file name, skips this file. a "." leaves it alone 735 */ 736 if (tmpname[0] == '\0') { 737 tty_prnt("Skipping file.\n"); 738 return(1); 739 } 740 if ((tmpname[0] == '.') && (tmpname[1] == '\0')) { 741 tty_prnt("Processing continues, name unchanged.\n"); 742 return(0); 743 } 744 745 /* 746 * ok the name changed. We may run into links that point at this 747 * file later. we have to remember where the user sent the file 748 * in order to repair any links. 749 */ 750 tty_prnt("Processing continues, name changed to: %s\n", tmpname); 751 res = add_name(arcn->name, arcn->nlen, tmpname); 752 arcn->nlen = strlcpy(arcn->name, tmpname, sizeof(arcn->name)); 753 if (arcn->nlen >= sizeof(arcn->name)) 754 arcn->nlen = sizeof(arcn->name) - 1; /* XXX truncate? */ 755 if (res < 0) 756 return(-1); 757 return(0); 758} 759 760/* 761 * set_dest() 762 * fix up the file name and the link name (if any) so this file will land 763 * in the destination directory (used during copy() -rw). 764 * Return: 765 * 0 if ok, -1 if failure (name too long) 766 */ 767 768int 769set_dest(ARCHD *arcn, char *dest_dir, int dir_len) 770{ 771 if (fix_path(arcn->name, &(arcn->nlen), dest_dir, dir_len) < 0) 772 return(-1); 773 774 /* 775 * It is really hard to deal with symlinks here, we cannot be sure 776 * if the name they point was moved (or will be moved). It is best to 777 * leave them alone. 778 */ 779 if ((arcn->type != PAX_HLK) && (arcn->type != PAX_HRG)) 780 return(0); 781 782 if (fix_path(arcn->ln_name, &(arcn->ln_nlen), dest_dir, dir_len) < 0) 783 return(-1); 784 return(0); 785} 786 787/* 788 * fix_path 789 * concatenate dir_name and or_name and store the result in or_name (if 790 * it fits). This is one ugly function. 791 * Return: 792 * 0 if ok, -1 if the final name is too long 793 */ 794 795static int 796fix_path(char *or_name, int *or_len, char *dir_name, int dir_len) 797{ 798 char *src; 799 char *dest; 800 char *start; 801 int len; 802 803 /* 804 * we shift the or_name to the right enough to tack in the dir_name 805 * at the front. We make sure we have enough space for it all before 806 * we start. since dest always ends in a slash, we skip of or_name 807 * if it also starts with one. 808 */ 809 start = or_name; 810 src = start + *or_len; 811 dest = src + dir_len; 812 if (*start == '/') { 813 ++start; 814 --dest; 815 } 816 if ((len = dest - or_name) > PAXPATHLEN) { 817 paxwarn(1, "File name %s/%s, too long", dir_name, start); 818 return(-1); 819 } 820 *or_len = len; 821 822 /* 823 * enough space, shift 824 */ 825 while (src >= start) 826 *dest-- = *src--; 827 src = dir_name + dir_len - 1; 828 829 /* 830 * splice in the destination directory name 831 */ 832 while (src >= dir_name) 833 *dest-- = *src--; 834 835 *(or_name + len) = '\0'; 836 return(0); 837} 838 839/* 840 * rep_name() 841 * walk down the list of replacement strings applying each one in order. 842 * when we find one with a successful substitution, we modify the name 843 * as specified. if required, we print the results. if the resulting name 844 * is empty, we will skip this archive member. We use the regexp(3) 845 * routines (regexp() ought to win a prize as having the most cryptic 846 * library function manual page). 847 * --Parameters-- 848 * name is the file name we are going to apply the regular expressions to 849 * (and may be modified) 850 * nsize is the size of the name buffer. 851 * nlen is the length of this name (and is modified to hold the length of 852 * the final string). 853 * prnt is a flag that says whether to print the final result. 854 * Return: 855 * 0 if substitution was successful, 1 if we are to skip the file (the name 856 * ended up empty) 857 */ 858 859static int 860rep_name(char *name, size_t nsize, int *nlen, int prnt) 861{ 862 REPLACE *pt; 863 char *inpt; 864 char *outpt; 865 char *endpt; 866 char *rpt; 867 int found = 0; 868 int res; 869 regmatch_t pm[MAXSUBEXP]; 870 char nname[PAXPATHLEN+1]; /* final result of all replacements */ 871 char buf1[PAXPATHLEN+1]; /* where we work on the name */ 872 873 /* 874 * copy the name into buf1, where we will work on it. We need to keep 875 * the orig string around so we can print out the result of the final 876 * replacement. We build up the final result in nname. inpt points at 877 * the string we apply the regular expression to. prnt is used to 878 * suppress printing when we handle replacements on the link field 879 * (the user already saw that substitution go by) 880 */ 881 pt = rephead; 882 (void)strlcpy(buf1, name, sizeof(buf1)); 883 inpt = buf1; 884 outpt = nname; 885 endpt = outpt + PAXPATHLEN; 886 887 /* 888 * try each replacement string in order 889 */ 890 while (pt != NULL) { 891 do { 892 char *oinpt = inpt; 893 /* 894 * check for a successful substitution, if not go to 895 * the next pattern, or cleanup if we were global 896 */ 897 if (regexec(&(pt->rcmp), inpt, MAXSUBEXP, pm, 0) != 0) 898 break; 899 900 /* 901 * ok we found one. We have three parts, the prefix 902 * which did not match, the section that did and the 903 * tail (that also did not match). Copy the prefix to 904 * the final output buffer (watching to make sure we 905 * do not create a string too long). 906 */ 907 found = 1; 908 rpt = inpt + pm[0].rm_so; 909 910 while ((inpt < rpt) && (outpt < endpt)) 911 *outpt++ = *inpt++; 912 if (outpt == endpt) 913 break; 914 915 /* 916 * for the second part (which matched the regular 917 * expression) apply the substitution using the 918 * replacement string and place it the prefix in the 919 * final output. If we have problems, skip it. 920 */ 921 if ((res = resub(&(pt->rcmp),pm,pt->nstr,oinpt,outpt,endpt)) 922 < 0) { 923 if (prnt) 924 paxwarn(1, "Replacement name error %s", 925 name); 926 return(1); 927 } 928 outpt += res; 929 930 /* 931 * we set up to look again starting at the first 932 * character in the tail (of the input string right 933 * after the last character matched by the regular 934 * expression (inpt always points at the first char in 935 * the string to process). If we are not doing a global 936 * substitution, we will use inpt to copy the tail to 937 * the final result. Make sure we do not overrun the 938 * output buffer 939 */ 940 inpt += pm[0].rm_eo - pm[0].rm_so; 941 942 if ((outpt == endpt) || (*inpt == '\0')) 943 break; 944 945 /* 946 * if the user wants global we keep trying to 947 * substitute until it fails, then we are done. 948 */ 949 } while (pt->flgs & GLOB); 950 951 if (found) 952 break; 953 954 /* 955 * a successful substitution did NOT occur, try the next one 956 */ 957 pt = pt->fow; 958 } 959 960 if (found) { 961 /* 962 * we had a substitution, copy the last tail piece (if there is 963 * room) to the final result 964 */ 965 while ((outpt < endpt) && (*inpt != '\0')) 966 *outpt++ = *inpt++; 967 968 *outpt = '\0'; 969 if ((outpt == endpt) && (*inpt != '\0')) { 970 if (prnt) 971 paxwarn(1,"Replacement name too long %s >> %s", 972 name, nname); 973 return(1); 974 } 975 976 /* 977 * inform the user of the result if wanted 978 */ 979 if (prnt && (pt->flgs & PRNT)) { 980 if (*nname == '\0') 981 (void)fprintf(stderr,"%s >> <empty string>\n", 982 name); 983 else 984 (void)fprintf(stderr,"%s >> %s\n", name, nname); 985 } 986 987 /* 988 * if empty inform the caller this file is to be skipped 989 * otherwise copy the new name over the orig name and return 990 */ 991 if (*nname == '\0') 992 return(1); 993 *nlen = strlcpy(name, nname, nsize); 994 } 995 return(0); 996} 997 998/* 999 * resub() 1000 * apply the replacement to the matched expression. expand out the old 1001 * style ed(1) subexpression expansion. 1002 * Return: 1003 * -1 if error, or the number of characters added to the destination. 1004 */ 1005 1006static int 1007resub(regex_t *rp, regmatch_t *pm, char *src, char *inpt, char *dest, 1008 char *destend) 1009{ 1010 char *spt; 1011 char *dpt; 1012 char c; 1013 regmatch_t *pmpt; 1014 int len; 1015 int subexcnt; 1016 1017 spt = src; 1018 dpt = dest; 1019 subexcnt = rp->re_nsub; 1020 while ((dpt < destend) && ((c = *spt++) != '\0')) { 1021 /* 1022 * see if we just have an ordinary replacement character 1023 * or we refer to a subexpression. 1024 */ 1025 if (c == '&') { 1026 pmpt = pm; 1027 } else if ((c == '\\') && (*spt >= '0') && (*spt <= '9')) { 1028 /* 1029 * make sure there is a subexpression as specified 1030 */ 1031 if ((len = *spt++ - '0') > subexcnt) 1032 return(-1); 1033 pmpt = pm + len; 1034 } else { 1035 /* 1036 * Ordinary character, just copy it 1037 */ 1038 if ((c == '\\') && (*spt != '\0')) 1039 c = *spt++; 1040 *dpt++ = c; 1041 continue; 1042 } 1043 1044 /* 1045 * continue if the subexpression is bogus 1046 */ 1047 if ((pmpt->rm_so < 0) || (pmpt->rm_eo < 0) || 1048 ((len = (int)(pmpt->rm_eo - pmpt->rm_so)) <= 0)) 1049 continue; 1050 1051 /* 1052 * copy the subexpression to the destination. 1053 * fail if we run out of space or the match string is damaged 1054 */ 1055 if (len > (destend - dpt)) 1056 len = destend - dpt; 1057 strncpy(dpt, inpt + pmpt->rm_so, len); 1058 dpt += len; 1059 } 1060 return(dpt - dest); 1061} 1062