/*	$OpenBSD: pat_rep.c,v 1.40 2015/11/17 19:01:34 mmcc Exp $	*/

/*	$NetBSD: pat_rep.c,v 1.4 1995/03/21 09:07:33 cgd Exp $	*/

/*-

 * Copyright (c) 1992 Keith Muller.

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Keith Muller of the University of California, San Diego.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/types.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <stdlib.h>

#include <errno.h>

#include <regex.h>

#include "pax.h"

#include "pat_rep.h"

#include "extern.h"

/*

 * routines to handle pattern matching, name modification (regular expression

 * substitution and interactive renames), and destination name modification for

 * copy (-rw). Both file name and link names are adjusted as required in these

 * routines.

 */

#define MAXSUBEXP	10		/* max subexpressions, DO NOT CHANGE */

static PATTERN *pathead = NULL;		/* file pattern match list head */

static PATTERN *pattail = NULL;		/* file pattern match list tail */

static REPLACE *rephead = NULL;		/* replacement string list head */

static REPLACE *reptail = NULL;		/* replacement string list tail */

static int rep_name(char *, size_t, int *, int);

static int tty_rename(ARCHD *);

static int fix_path(char *, int *, char *, int);

static int fn_match(char *, char *, char **);

static char * range_match(char *, int);

static int resub(regex_t *, regmatch_t *, char *, char *, char *, char *);

/*

 * rep_add()

 *	parses the -s replacement string; compiles the regular expression

 *	and stores the compiled value and it's replacement string together in

 *	replacement string list. Input to this function is of the form:

 *		/old/new/pg

 *	The first char in the string specifies the delimiter used by this

 *	replacement string. "Old" is a regular expression in "ed" format which

 *	is compiled by regcomp() and is applied to filenames. "new" is the

 *	substitution string; p and g are options flags for printing and global

 *	replacement (over the single filename)

 * Return:

 *	0 if a proper replacement string and regular expression was added to

 *	the list of replacement patterns; -1 otherwise.

 */

int

rep_add(char *str)

{

	char *pt1;

	char *pt2;

	REPLACE *rep;

	int res;

	char rebuf[BUFSIZ];

	/*

	 * throw out the bad parameters

	 */

	}

	/*

	 * first character in the string specifies what the delimiter is for

	 * this expression

	 */

		}

	}

	}

	/*

	 * allocate space for the node that handles this replacement pattern

	 * and split out the regular expression and try to compile it

	 */

	}

	}

	/*

	 * put the delimiter back in case we need an error message and

	 * locate the delimiter at the end of the replacement string

	 * we then point the node at the new substitution string

	 */

		}

	}

	}

	/*

	 * set the options if any

	 */

		case 'g':

		case 'G':

		case 'p':

		case 'P':

		default:

		}

	}

	/*

	 * all done, link it in at the end

	 */

	}

}

/*

 * pat_add()

 *	add a pattern match to the pattern match list. Pattern matches are used

 *	to select which archive members are extracted. (They appear as

 *	arguments to pax in the list and read modes). If no patterns are

 *	supplied to pax, all members in the archive will be selected (and the

 *	pattern match list is empty).

 * Return:

 *	0 if the pattern was added to the list, -1 otherwise

 */

int

pat_add(char *str, char *chdirname)

{

	PATTERN *pt;

	/*

	 * throw out the junk

	 */

	}

	/*

	 * allocate space for the pattern and store the pattern. the pattern is

	 * part of argv so do not bother to copy it, just point at it. Add the

	 * node to the end of the pattern list

	 */

	}

	}

}

/*

 * pat_chk()

 *	complain if any the user supplied pattern did not result in a match to

 *	a selected archive member.

 */

void

pat_chk(void)

	PATTERN *pt;

	/*

	 * walk down the list checking the flags to make sure MTCH was set,

	 * if not complain

	 */

		}

	}

/*

 * pat_sel()

 *	the archive member which matches a pattern was selected. Mark the

 *	pattern as having selected an archive member. arcn->pat points at the

 *	pattern that was matched. arcn->pat is set in pat_match()

 *

 *	NOTE: When the -c option is used, we are called when there was no match

 *	by pat_match() (that means we did match before the inverted sense of

 *	the logic). Now this seems really strange at first, but with -c we

 *	need to keep track of those patterns that cause an archive member to NOT

 *	be selected (it found an archive member with a specified pattern)

 * Return:

 *	0 if the pattern pointed at by arcn->pat was tagged as creating a

 *	match, -1 otherwise.

 */

int

pat_sel(ARCHD *arcn)

	PATTERN *pt;

	PATTERN **ppt;

	size_t len;

	/*

	 * if no patterns just return

	 */

	/*

	 * when we are NOT limited to a single match per pattern mark the

	 * pattern and return

	 */

	}

	/*

	 * we reach this point only when we allow a single selected match per

	 * pattern, if the pattern matches a directory and we do not have -d

	 * (dflag) we are done with this pattern. We may also be handed a file

	 * in the subtree of a directory. in that case when we are operating

	 * with -d, this pattern was already selected and we are done

	 */

		/*

		 * ok we matched a directory and we are allowing

		 * subtree matches but because of the -n only its children will

		 * match. This is tagged as a DIR_MTCH type.

		 * WATCH IT, the code assumes that pt->pend points

		 * into arcn->name and arcn->name has not been modified.

		 * If not we will have a big mess. Yup this is another kludge

		 */

		/*

		 * if this was a prefix match, remove trailing part of path

		 * so we can copy it. Future matches will be exact prefix match

		 */

		}

		/*

		 * put the trailing / back in the source string

		 */

		}

		/*

		 * strip off any trailing /, this should really never happen

		 */

		}

	}

	/*

	 * we are then done with this pattern, so we delete it from the list

	 * because it can never be used for another match.

	 * Seems kind of strange to do for a -c, but the pax spec is really

	 * vague on the interaction of -c, -n and -d. We assume that when -c

	 * and the pattern rejects a member (i.e. it matched it) it is done.

	 * In effect we place the order of the flags as having -c last.

	 */

	}

		/*

		 * should never happen....

		 */

	}

}

/*

 * pat_match()

 *	see if this archive member matches any supplied pattern, if a match

 *	is found, arcn->pat is set to point at the potential pattern. Later if

 *	this archive member is "selected" we process and mark the pattern as

 *	one which matched a selected archive member (see pat_sel())

 * Return:

 *	0 if this archive member should be processed, 1 if it should be

 *	skipped and -1 if we are done with all patterns (and pax should quit

 *	looking for more members)

 */

int

pat_match(ARCHD *arcn)

	PATTERN *pt;

	/*

	 * if there are no more patterns and we have -n (and not -c) we are

	 * done. otherwise with no patterns to match, matches all

	 */

	}

	/*

	 * have to search down the list one at a time looking for a match.

	 */

		/*

		 * check for a file name match unless we have DIR_MTCH set in

		 * this pattern then we want a prefix match

		 */

			/*

			 * this pattern was matched before to a directory

			 * as we must have -n set for this (but not -d). We can

			 * only match CHILDREN of that directory so we must use

			 * an exact prefix match (no wildcards).

			 */

			    (strncmp(pt->pstr, arcn->name, pt->plen) == 0))

	}

	/*

	 * return the result, remember that cflag (-c) inverts the sense of a

	 * match

	 */

	/*

	 * we had a match, now when we invert the sense (-c) we reject this

	 * member. However we have to tag the pattern a being successful, (in a

	 * match, not in selecting a archive member) so we call pat_sel() here.

	 */

}

/*

 * fn_match()

 * Return:

 *	0 if this archive member should be processed, 1 if it should be

 *	skipped and -1 if we are done with all patterns (and pax should quit

 *	looking for more members)

 *	Note: *pend may be changed to show where the prefix ends.

 */

static int

fn_match(char *pattern, char *string, char **pend)

{

	char c;

	char test;

	for (;;) {

		case '\0':

			/*

			 * Ok we found an exact match

			 */

			/*

			 * Check if it is a prefix match

			 */

			/*

			 * It is a prefix match, remember where the trailing

			 * / is located

			 */

		case '?':

			break;

		case '*':

			/*

			 * Collapse multiple *'s.

			 */

			/*

			 * Optimized hack for pattern with a * at the end

			 */

			/*

			 * General case, use recursion.

			 */

			}

		case '[':

			/*

			 * range match

			 */

			    ((pattern = range_match(pattern, test)) == NULL))

			break;

		case '\\':

		default:

			break;

		}

	}

	/* NOTREACHED */

}

static char *

range_match(char *pattern, int test)

{

	char c;

	char c2;

	int negate;

		/*

		 * Illegal pattern

		 */

		    (c2 != ']')) {

	}

}

/*

 * has_dotdot()

 *	Returns true iff the supplied path contains a ".." component.

 */

int

has_dotdot(const char *path)

{

		    (p[2] == '/' || p[2] == '\0'))

	}

}

/*

 * mod_name()

 *	modify a selected file name. first attempt to apply replacement string

 *	expressions, then apply interactive file rename. We apply replacement

 *	string expressions to both filenames and file links (if we didn't the

 *	links would point to the wrong place, and we could never be able to

 *	move an archive that has a file link in it). When we rename files

 *	interactively, we store that mapping (old name to user input name) so

 *	if we spot any file links to the old file name in the future, we will

 *	know exactly how to fix the file link.

 * Return:

 *	0 continue to  process file, 1 skip this file, -1 pax is finished

 */

int

mod_name(ARCHD *arcn)

	/*

	 * Strip off leading '/' if appropriate.

	 * Currently, this option is only set for the tar format.

	 */

		} else {

			    strlen(arcn->name));

		}

		}

	}

	    PAX_IS_HARDLINK(arcn->type)) {

		} else {

			    strlen(arcn->ln_name));

		}

		}

	}

			    (p[2] == '/' || p[2] == '\0'))

		}

			    (int)(last - arcn->name), arcn->name);

			else {

			}

		}

	}

	/*

	 * IMPORTANT: We have a problem. what do we do with symlinks?

	 * Modifying a hard link name makes sense, as we know the file it

	 * points at should have been seen already in the archive (and if it

	 * wasn't seen because of a read error or a bad archive, we lose

	 * anyway). But there are no such requirements for symlinks. On one

	 * hand the symlink that refers to a file in the archive will have to

	 * be modified to so it will still work at its new location in the

	 * file system. On the other hand a symlink that points elsewhere (and

	 * should continue to do so) should not be modified. There is clearly

	 * no perfect solution here. So we handle them like hardlinks. Clearly

	 * a replacement made by the interactive rename mapping is very likely

	 * to be correct since it applies to a single file and is an exact

	 * match. The regular expression replacements are a little harder to

	 * justify though. We claim that the symlink name is only likely

	 * to be replaced when it points within the file tree being moved and

	 * in that case it should be modified. what we really need to do is to

	 * call an oracle here. :)

	 */

		/*

		 * we have replacement strings, modify the name and the link

		 * name if any.

		 */

			    sizeof(arcn->ln_name), &(arcn->ln_nlen), 0)) != 0)

		}

	}

		/*

		 * perform interactive file rename, then map the link if any

		 */

			    sizeof(arcn->ln_name));

	}

}

/*

 * tty_rename()

 *	Prompt the user for a replacement file name. A "." keeps the old name,

 *	a empty line skips the file, and an EOF on reading the tty, will cause

 *	pax to stop processing and exit. Otherwise the file name input, replaces

 *	the old one.

 * Return:

 *	0 process this file, 1 skip this file, -1 we need to exit pax

 */

static int

tty_rename(ARCHD *arcn)

{

	char tmpname[PAXPATHLEN+2];

	int res;

	/*

	 * prompt user for the replacement name for a file, keep trying until

	 * we get some reasonable input. Archives may have more than one file

	 * on them with the same name (from updates etc). We print verbose info

	 * on the file so the user knows what is up.

	 */

	for (;;) {

		}

		}

		break;

	}

	/*

	 * empty file name, skips this file. a "." leaves it alone

	 */

	}

	}

	/*

	 * ok the name changed. We may run into links that point at this

	 * file later. we have to remember where the user sent the file

	 * in order to repair any links.

	 */

}

/*

 * set_dest()

 *	fix up the file name and the link name (if any) so this file will land

 *	in the destination directory (used during copy() -rw).

 * Return:

 *	0 if ok, -1 if failure (name too long)

 */

int

set_dest(ARCHD *arcn, char *dest_dir, int dir_len)

{

	/*

	 * It is really hard to deal with symlinks here, we cannot be sure

	 * if the name they point was moved (or will be moved). It is best to

	 * leave them alone.

	 */

}

/*

 * fix_path

 *	concatenate dir_name and or_name and store the result in or_name (if

 *	it fits). This is one ugly function.

 * Return:

 *	0 if ok, -1 if the final name is too long

 */

static int

fix_path(char *or_name, int *or_len, char *dir_name, int dir_len)

{

	char *src;

	char *dest;

	char *start;

	int len;

	/*

	 * we shift the or_name to the right enough to tack in the dir_name

	 * at the front. We make sure we have enough space for it all before

	 * we start. since dest always ends in a slash, we skip of or_name

	 * if it also starts with one.

	 */

	}

	}

	/*

	 * enough space, shift

	 */

	/*

	 * splice in the destination directory name

	 */

}

/*

 * rep_name()

 *	walk down the list of replacement strings applying each one in order.

 *	when we find one with a successful substitution, we modify the name

 *	as specified. if required, we print the results. if the resulting name

 *	is empty, we will skip this archive member. We use the regexp(3)

 *	routines (regexp() ought to win a prize as having the most cryptic

 *	library function manual page).

 *	--Parameters--

 *	name is the file name we are going to apply the regular expressions to

 *	(and may be modified)

 *	nsize is the size of the name buffer.

 *	nlen is the length of this name (and is modified to hold the length of

 *	the final string).

 *	prnt is a flag that says whether to print the final result.

 * Return:

 *	0 if substitution was successful, 1 if we are to skip the file (the name

 *	ended up empty)

 */

static int

rep_name(char *name, size_t nsize, int *nlen, int prnt)

{

	REPLACE *pt;

	char *inpt;

	char *outpt;

	char *endpt;

	char *rpt;

	int res;

	regmatch_t pm[MAXSUBEXP];

	char nname[PAXPATHLEN+1];	/* final result of all replacements */

	char buf1[PAXPATHLEN+1];	/* where we work on the name */

	/*

	 * copy the name into buf1, where we will work on it. We need to keep

	 * the orig string around so we can print out the result of the final

	 * replacement. We build up the final result in nname. inpt points at

	 * the string we apply the regular expression to. prnt is used to

	 * suppress printing when we handle replacements on the link field

	 * (the user already saw that substitution go by)

	 */

	/*

	 * try each replacement string in order

	 */

		do {

			/*

			 * check for a successful substitution, if not go to

			 * the next pattern, or cleanup if we were global

			 */

			/*

			 * ok we found one. We have three parts, the prefix

			 * which did not match, the section that did and the

			 * tail (that also did not match). Copy the prefix to

			 * the final output buffer (watching to make sure we

			 * do not create a string too long).

			 */

			/*

			 * for the second part (which matched the regular

			 * expression) apply the substitution using the

			 * replacement string and place it the prefix in the

			 * final output. If we have problems, skip it.

			 */

			    < 0) {

					    name);

			}

			/*

			 * we set up to look again starting at the first

			 * character in the tail (of the input string right

			 * after the last character matched by the regular

			 * expression (inpt always points at the first char in

			 * the string to process). If we are not doing a global

			 * substitution, we will use inpt to copy the tail to

			 * the final result. Make sure we do not overrun the

			 * output buffer

			 */

				break;

			/*

			 * if the user wants global we keep trying to

			 * substitute until it fails, then we are done.

			 */

		/*