2 * Copyright (c) 1992 Keith Muller.
3 * Copyright (c) 1992, 1993
4 * The Regents of the University of California. All rights reserved.
6 * This code is derived from software contributed to Berkeley by
7 * Keith Muller of the University of California, San Diego.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)pat_rep.c 8.2 (Berkeley) 4/18/94
34 * $FreeBSD: src/bin/pax/pat_rep.c,v 1.15.2.1 2001/08/01 05:03:11 obrien Exp $
35 * $DragonFly: src/bin/pax/pat_rep.c,v 1.8 2006/09/27 21:58:08 pavalos Exp $
38 #include <sys/types.h>
51 * routines to handle pattern matching, name modification (regular expression
52 * substitution and interactive renames), and destination name modification for
53 * copy (-rw). Both file name and link names are adjusted as required in these
57 #define MAXSUBEXP 10 /* max subexpressions, DO NOT CHANGE */
58 static PATTERN
*pathead
= NULL
; /* file pattern match list head */
59 static PATTERN
*pattail
= NULL
; /* file pattern match list tail */
60 static REPLACE
*rephead
= NULL
; /* replacement string list head */
61 static REPLACE
*reptail
= NULL
; /* replacement string list tail */
63 static int rep_name (char *, int *, int);
64 static int tty_rename (ARCHD
*);
65 static int fix_path (char *, int *, char *, int);
66 static int fn_match (char *, char *, char **);
67 static char * range_match (char *, int);
68 static int resub (regex_t
*, regmatch_t
*, char *, char *, char *);
72 * parses the -s replacement string; compiles the regular expression
73 * and stores the compiled value and it's replacement string together in
74 * replacement string list. Input to this function is of the form:
76 * The first char in the string specifies the delimiter used by this
77 * replacement string. "Old" is a regular expression in "ed" format which
78 * is compiled by regcomp() and is applied to filenames. "new" is the
79 * substitution string; p and g are options flags for printing and global
80 * replacement (over the single filename)
82 * 0 if a proper replacement string and regular expression was added to
83 * the list of replacement patterns; -1 otherwise.
96 * throw out the bad parameters
98 if ((str
== NULL
) || (*str
== '\0')) {
99 paxwarn(1, "Empty replacement string");
104 * first character in the string specifies what the delimiter is for
107 if ((pt1
= strchr(str
+1, *str
)) == NULL
) {
108 paxwarn(1, "Invalid replacement string %s", str
);
113 * allocate space for the node that handles this replacement pattern
114 * and split out the regular expression and try to compile it
116 if ((rep
= (REPLACE
*)malloc(sizeof(REPLACE
))) == NULL
) {
117 paxwarn(1, "Unable to allocate memory for replacement string");
122 if ((res
= regcomp(&(rep
->rcmp
), str
+1, 0)) != 0) {
123 regerror(res
, &(rep
->rcmp
), rebuf
, sizeof(rebuf
));
124 paxwarn(1, "%s while compiling regular expression %s", rebuf
, str
);
130 * put the delimiter back in case we need an error message and
131 * locate the delimiter at the end of the replacement string
132 * we then point the node at the new substitution string
135 if ((pt2
= strchr(pt1
, *str
)) == NULL
) {
136 regfree(&(rep
->rcmp
));
138 paxwarn(1, "Invalid replacement string %s", str
);
148 * set the options if any
150 while (*pt2
!= '\0') {
161 regfree(&(rep
->rcmp
));
164 paxwarn(1, "Invalid replacement string option %s", str
);
171 * all done, link it in at the end
174 if (rephead
== NULL
) {
175 reptail
= rephead
= rep
;
185 * add a pattern match to the pattern match list. Pattern matches are used
186 * to select which archive members are extracted. (They appear as
187 * arguments to pax in the list and read modes). If no patterns are
188 * supplied to pax, all members in the archive will be selected (and the
189 * pattern match list is empty).
191 * 0 if the pattern was added to the list, -1 otherwise
195 pat_add(char *str
, char *chdname
)
202 if ((str
== NULL
) || (*str
== '\0')) {
203 paxwarn(1, "Empty pattern string");
208 * allocate space for the pattern and store the pattern. the pattern is
209 * part of argv so do not bother to copy it, just point at it. Add the
210 * node to the end of the pattern list
212 if ((pt
= (PATTERN
*)malloc(sizeof(PATTERN
))) == NULL
) {
213 paxwarn(1, "Unable to allocate memory for pattern string");
219 pt
->plen
= strlen(str
);
222 pt
->chdname
= chdname
;
224 if (pathead
== NULL
) {
225 pattail
= pathead
= pt
;
235 * complain if any the user supplied pattern did not result in a match to
236 * a selected archive member.
246 * walk down the list checking the flags to make sure MTCH was set,
249 for (pt
= pathead
; pt
!= NULL
; pt
= pt
->fow
) {
253 paxwarn(1, "WARNING! These patterns were not matched:");
256 fprintf(stderr
, "%s\n", pt
->pstr
);
262 * the archive member which matches a pattern was selected. Mark the
263 * pattern as having selected an archive member. arcn->pat points at the
264 * pattern that was matched. arcn->pat is set in pat_match()
266 * NOTE: When the -c option is used, we are called when there was no match
267 * by pat_match() (that means we did match before the inverted sense of
268 * the logic). Now this seems really strange at first, but with -c we
269 * need to keep track of those patterns that cause an archive member to NOT
270 * be selected (it found an archive member with a specified pattern)
272 * 0 if the pattern pointed at by arcn->pat was tagged as creating a
273 * match, -1 otherwise.
284 * if no patterns just return
286 if ((pathead
== NULL
) || ((pt
= arcn
->pat
) == NULL
))
290 * when we are NOT limited to a single match per pattern mark the
299 * we reach this point only when we allow a single selected match per
300 * pattern, if the pattern matches a directory and we do not have -d
301 * (dflag) we are done with this pattern. We may also be handed a file
302 * in the subtree of a directory. in that case when we are operating
303 * with -d, this pattern was already selected and we are done
305 if (pt
->flgs
& DIR_MTCH
)
308 if (!dflag
&& ((pt
->pend
!= NULL
) || (arcn
->type
== PAX_DIR
))) {
310 * ok we matched a directory and we are allowing
311 * subtree matches but because of the -n only its children will
312 * match. This is tagged as a DIR_MTCH type.
313 * WATCH IT, the code assumes that pt->pend points
314 * into arcn->name and arcn->name has not been modified.
315 * If not we will have a big mess. Yup this is another kludge
319 * if this was a prefix match, remove trailing part of path
320 * so we can copy it. Future matches will be exact prefix match
322 if (pt
->pend
!= NULL
)
325 if ((pt
->pstr
= strdup(arcn
->name
)) == NULL
) {
326 paxwarn(1, "Pattern select out of memory");
327 if (pt
->pend
!= NULL
)
334 * put the trailing / back in the source string
336 if (pt
->pend
!= NULL
) {
340 pt
->plen
= strlen(pt
->pstr
);
343 * strip off any trailing /, this should really never happen
346 if (*(pt
->pstr
+ len
) == '/') {
347 *(pt
->pstr
+ len
) = '\0';
350 pt
->flgs
= DIR_MTCH
| MTCH
;
356 * we are then done with this pattern, so we delete it from the list
357 * because it can never be used for another match.
358 * Seems kind of strange to do for a -c, but the pax spec is really
359 * vague on the interaction of -c, -n and -d. We assume that when -c
360 * and the pattern rejects a member (i.e. it matched it) it is done.
361 * In effect we place the order of the flags as having -c last.
365 while ((pt
!= NULL
) && (pt
!= arcn
->pat
)) {
372 * should never happen....
374 paxwarn(1, "Pattern list inconsistent");
385 * see if this archive member matches any supplied pattern, if a match
386 * is found, arcn->pat is set to point at the potential pattern. Later if
387 * this archive member is "selected" we process and mark the pattern as
388 * one which matched a selected archive member (see pat_sel())
390 * 0 if this archive member should be processed, 1 if it should be
391 * skipped and -1 if we are done with all patterns (and pax should quit
392 * looking for more members)
396 pat_match(ARCHD
*arcn
)
403 * if there are no more patterns and we have -n (and not -c) we are
404 * done. otherwise with no patterns to match, matches all
406 if (pathead
== NULL
) {
413 * have to search down the list one at a time looking for a match.
418 * check for a file name match unless we have DIR_MTCH set in
419 * this pattern then we want a prefix match
421 if (pt
->flgs
& DIR_MTCH
) {
423 * this pattern was matched before to a directory
424 * as we must have -n set for this (but not -d). We can
425 * only match CHILDREN of that directory so we must use
426 * an exact prefix match (no wildcards).
428 if ((arcn
->name
[pt
->plen
] == '/') &&
429 (strncmp(pt
->pstr
, arcn
->name
, pt
->plen
) == 0))
431 } else if (fn_match(pt
->pstr
, arcn
->name
, &pt
->pend
) == 0)
437 * return the result, remember that cflag (-c) inverts the sense of a
441 return(cflag
? 0 : 1);
444 * we had a match, now when we invert the sense (-c) we reject this
445 * member. However we have to tag the pattern a being successful, (in a
446 * match, not in selecting a archive member) so we call pat_sel() here.
452 if (pat_sel(arcn
) < 0)
461 * 0 if this archive member should be processed, 1 if it should be
462 * skipped and -1 if we are done with all patterns (and pax should quit
463 * looking for more members)
464 * Note: *pend may be changed to show where the prefix ends.
468 fn_match(char *pattern
, char *string
, char **pend
)
475 switch (c
= *pattern
++) {
478 * Ok we found an exact match
484 * Check if it is a prefix match
486 if ((dflag
== 1) || (*string
!= '/'))
490 * It is a prefix match, remember where the trailing
496 if (*string
++ == '\0')
502 * Collapse multiple *'s.
508 * Optimized hack for pattern with a * at the end
514 * General case, use recursion.
516 while (*string
!= '\0') {
517 if (!fn_match(pattern
, string
, pend
))
526 if (((test
= *string
++) == '\0') ||
527 ((pattern
= range_match(pattern
, test
)) == NULL
))
541 range_match(char *pattern
, int test
)
548 if ((negate
= (*pattern
== '!')) != 0)
551 while ((c
= *pattern
++) != ']') {
558 if ((*pattern
== '-') && ((c2
= pattern
[1]) != '\0') &&
560 if ((c
<= test
) && (test
<= c2
))
563 } else if (c
== test
)
566 return (ok
== negate
? NULL
: pattern
);
571 * modify a selected file name. first attempt to apply replacement string
572 * expressions, then apply interactive file rename. We apply replacement
573 * string expressions to both filenames and file links (if we didn't the
574 * links would point to the wrong place, and we could never be able to
575 * move an archive that has a file link in it). When we rename files
576 * interactively, we store that mapping (old name to user input name) so
577 * if we spot any file links to the old file name in the future, we will
578 * know exactly how to fix the file link.
580 * 0 continue to process file, 1 skip this file, -1 pax is finished
584 mod_name(ARCHD
*arcn
)
589 * Strip off leading '/' if appropriate.
590 * Currently, this option is only set for the tar format.
592 if (rmleadslash
&& arcn
->name
[0] == '/') {
593 if (arcn
->name
[1] == '\0') {
596 memmove(arcn
->name
, &arcn
->name
[1],
600 if (rmleadslash
< 2) {
602 paxwarn(0, "Removing leading / from absolute path names in the archive");
605 if (rmleadslash
&& arcn
->ln_name
[0] == '/' &&
606 (arcn
->type
== PAX_HLK
|| arcn
->type
== PAX_HRG
)) {
607 if (arcn
->ln_name
[1] == '\0') {
608 arcn
->ln_name
[0] = '.';
610 memmove(arcn
->ln_name
, &arcn
->ln_name
[1],
611 strlen(arcn
->ln_name
));
614 if (rmleadslash
< 2) {
616 paxwarn(0, "Removing leading / from absolute path names in the archive");
621 * IMPORTANT: We have a problem. what do we do with symlinks?
622 * Modifying a hard link name makes sense, as we know the file it
623 * points at should have been seen already in the archive (and if it
624 * wasn't seen because of a read error or a bad archive, we lose
625 * anyway). But there are no such requirements for symlinks. On one
626 * hand the symlink that refers to a file in the archive will have to
627 * be modified to so it will still work at its new location in the
628 * file system. On the other hand a symlink that points elsewhere (and
629 * should continue to do so) should not be modified. There is clearly
630 * no perfect solution here. So we handle them like hardlinks. Clearly
631 * a replacement made by the interactive rename mapping is very likely
632 * to be correct since it applies to a single file and is an exact
633 * match. The regular expression replacements are a little harder to
634 * justify though. We claim that the symlink name is only likely
635 * to be replaced when it points within the file tree being moved and
636 * in that case it should be modified. what we really need to do is to
637 * call an oracle here. :)
639 if (rephead
!= NULL
) {
641 * we have replacement strings, modify the name and the link
644 if ((res
= rep_name(arcn
->name
, &(arcn
->nlen
), 1)) != 0)
647 if (((arcn
->type
== PAX_SLK
) || (arcn
->type
== PAX_HLK
) ||
648 (arcn
->type
== PAX_HRG
)) &&
649 ((res
= rep_name(arcn
->ln_name
, &(arcn
->ln_nlen
), 0)) != 0))
655 * perform interactive file rename, then map the link if any
657 if ((res
= tty_rename(arcn
)) != 0)
659 if ((arcn
->type
== PAX_SLK
) || (arcn
->type
== PAX_HLK
) ||
660 (arcn
->type
== PAX_HRG
))
661 sub_name(arcn
->ln_name
, &(arcn
->ln_nlen
), sizeof(arcn
->ln_name
));
668 * Prompt the user for a replacement file name. A "." keeps the old name,
669 * a empty line skips the file, and an EOF on reading the tty, will cause
670 * pax to stop processing and exit. Otherwise the file name input, replaces
673 * 0 process this file, 1 skip this file, -1 we need to exit pax
677 tty_rename(ARCHD
*arcn
)
679 char tmpname
[PAXPATHLEN
+2];
683 * prompt user for the replacement name for a file, keep trying until
684 * we get some reasonable input. Archives may have more than one file
685 * on them with the same name (from updates etc). We print verbose info
686 * on the file so the user knows what is up.
688 tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0
);
692 tty_prnt("Input new name, or a \".\" to keep the old name, ");
693 tty_prnt("or a \"return\" to skip this file.\n");
694 tty_prnt("Input > ");
695 if (tty_read(tmpname
, sizeof(tmpname
)) < 0)
697 if (strcmp(tmpname
, "..") == 0) {
698 tty_prnt("Try again, illegal file name: ..\n");
701 if (strlen(tmpname
) > PAXPATHLEN
) {
702 tty_prnt("Try again, file name too long\n");
709 * empty file name, skips this file. a "." leaves it alone
711 if (tmpname
[0] == '\0') {
712 tty_prnt("Skipping file.\n");
715 if ((tmpname
[0] == '.') && (tmpname
[1] == '\0')) {
716 tty_prnt("Processing continues, name unchanged.\n");
721 * ok the name changed. We may run into links that point at this
722 * file later. we have to remember where the user sent the file
723 * in order to repair any links.
725 tty_prnt("Processing continues, name changed to: %s\n", tmpname
);
726 res
= add_name(arcn
->name
, arcn
->nlen
, tmpname
);
727 arcn
->nlen
= l_strncpy(arcn
->name
, tmpname
, sizeof(arcn
->name
) - 1);
728 arcn
->name
[arcn
->nlen
] = '\0';
736 * fix up the file name and the link name (if any) so this file will land
737 * in the destination directory (used during copy() -rw).
739 * 0 if ok, -1 if failure (name too long)
743 set_dest(ARCHD
*arcn
, char *dest_dir
, int dir_len
)
745 if (fix_path(arcn
->name
, &(arcn
->nlen
), dest_dir
, dir_len
) < 0)
749 * It is really hard to deal with symlinks here, we cannot be sure
750 * if the name they point was moved (or will be moved). It is best to
753 if ((arcn
->type
!= PAX_HLK
) && (arcn
->type
!= PAX_HRG
))
756 if (fix_path(arcn
->ln_name
, &(arcn
->ln_nlen
), dest_dir
, dir_len
) < 0)
763 * concatenate dir_name and or_name and store the result in or_name (if
764 * it fits). This is one ugly function.
766 * 0 if ok, -1 if the final name is too long
770 fix_path( char *or_name
, int *or_len
, char *dir_name
, int dir_len
)
778 * we shift the or_name to the right enough to tack in the dir_name
779 * at the front. We make sure we have enough space for it all before
780 * we start. since dest always ends in a slash, we skip of or_name
781 * if it also starts with one.
784 src
= start
+ *or_len
;
785 dest
= src
+ dir_len
;
790 if ((len
= dest
- or_name
) > PAXPATHLEN
) {
791 paxwarn(1, "File name %s/%s, too long", dir_name
, start
);
797 * enough space, shift
801 src
= dir_name
+ dir_len
- 1;
804 * splice in the destination directory name
806 while (src
>= dir_name
)
809 *(or_name
+ len
) = '\0';
815 * walk down the list of replacement strings applying each one in order.
816 * when we find one with a successful substitution, we modify the name
817 * as specified. if required, we print the results. if the resulting name
818 * is empty, we will skip this archive member. We use the regexp(3)
819 * routines (regexp() ought to win a prize as having the most cryptic
820 * library function manual page).
822 * name is the file name we are going to apply the regular expressions to
823 * (and may be modified)
824 * nlen is the length of this name (and is modified to hold the length of
826 * prnt is a flag that says whether to print the final result.
828 * 0 if substitution was successful, 1 if we are to skip the file (the name
833 rep_name(char *name
, int *nlen
, int prnt
)
842 regmatch_t pm
[MAXSUBEXP
];
843 char nname
[PAXPATHLEN
+1]; /* final result of all replacements */
844 char buf1
[PAXPATHLEN
+1]; /* where we work on the name */
847 * copy the name into buf1, where we will work on it. We need to keep
848 * the orig string around so we can print out the result of the final
849 * replacement. We build up the final result in nname. inpt points at
850 * the string we apply the regular expression to. prnt is used to
851 * suppress printing when we handle replacements on the link field
852 * (the user already saw that substitution go by)
858 endpt
= outpt
+ PAXPATHLEN
;
861 * try each replacement string in order
866 * check for a successful substitution, if not go to
867 * the next pattern, or cleanup if we were global
869 if (regexec(&(pt
->rcmp
), inpt
, MAXSUBEXP
, pm
, 0) != 0)
873 * ok we found one. We have three parts, the prefix
874 * which did not match, the section that did and the
875 * tail (that also did not match). Copy the prefix to
876 * the final output buffer (watching to make sure we
877 * do not create a string too long).
880 rpt
= inpt
+ pm
[0].rm_so
;
882 while ((inpt
< rpt
) && (outpt
< endpt
))
888 * for the second part (which matched the regular
889 * expression) apply the substitution using the
890 * replacement string and place it the prefix in the
891 * final output. If we have problems, skip it.
893 if ((res
= resub(&(pt
->rcmp
),pm
,pt
->nstr
,outpt
,endpt
))
896 paxwarn(1, "Replacement name error %s",
903 * we set up to look again starting at the first
904 * character in the tail (of the input string right
905 * after the last character matched by the regular
906 * expression (inpt always points at the first char in
907 * the string to process). If we are not doing a global
908 * substitution, we will use inpt to copy the tail to
909 * the final result. Make sure we do not overrun the
912 inpt
+= pm
[0].rm_eo
- pm
[0].rm_so
;
914 if ((outpt
== endpt
) || (*inpt
== '\0'))
918 * if the user wants global we keep trying to
919 * substitute until it fails, then we are done.
921 } while (pt
->flgs
& GLOB
);
927 * a successful substitution did NOT occur, try the next one
934 * we had a substitution, copy the last tail piece (if there is
935 * room) to the final result
937 while ((outpt
< endpt
) && (*inpt
!= '\0'))
941 if ((outpt
== endpt
) && (*inpt
!= '\0')) {
943 paxwarn(1,"Replacement name too long %s >> %s",
949 * inform the user of the result if wanted
951 if (prnt
&& (pt
->flgs
& PRNT
)) {
953 fprintf(stderr
,"%s >> <empty string>\n",
956 fprintf(stderr
,"%s >> %s\n", name
, nname
);
960 * if empty inform the caller this file is to be skipped
961 * otherwise copy the new name over the orig name and return
965 *nlen
= l_strncpy(name
, nname
, PAXPATHLEN
+ 1);
966 name
[PAXPATHLEN
] = '\0';
973 * apply the replacement to the matched expression. expand out the old
974 * style ed(1) subexpression expansion.
976 * -1 if error, or the number of characters added to the destination.
980 resub(regex_t
*rp
, regmatch_t
*pm
, char *src
, char *dest
,
992 subexcnt
= rp
->re_nsub
;
993 while ((dpt
< destend
) && ((c
= *spt
++) != '\0')) {
995 * see if we just have an ordinary replacement character
996 * or we refer to a subexpression.
1000 } else if ((c
== '\\') && (*spt
>= '0') && (*spt
<= '9')) {
1002 * make sure there is a subexpression as specified
1004 if ((len
= *spt
++ - '0') > subexcnt
)
1009 * Ordinary character, just copy it
1011 if ((c
== '\\') && ((*spt
== '\\') || (*spt
== '&')))
1018 * continue if the subexpression is bogus
1020 if ((pmpt
->rm_so
< 0) || (pmpt
->rm_eo
< 0) ||
1021 ((len
= pmpt
->rm_eo
- pmpt
->rm_so
) <= 0))
1025 * copy the subexpression to the destination.
1026 * fail if we run out of space or the match string is damaged
1028 if (len
> (destend
- dpt
))
1029 len
= destend
- dpt
;
1030 if (l_strncpy(dpt
, src
+ pmpt
->rm_so
, len
) != len
)