/*	$OpenBSD: ftree.c,v 1.39 2016/06/03 23:22:20 tedu Exp $	*/

/*	$NetBSD: ftree.c,v 1.4 1995/03/21 09:07:21 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 <unistd.h>

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <fts.h>

#include "pax.h"

#include "ftree.h"

#include "extern.h"

/*

 * routines to interface with the fts library function.

 *

 * file args supplied to pax are stored on a single linked list (of type FTREE)

 * and given to fts to be processed one at a time. pax "selects" files from

 * the expansion of each arg into the corresponding file tree (if the arg is a

 * directory, otherwise the node itself is just passed to pax). The selection

 * is modified by the -n and -u flags. The user is informed when a specific

 * file arg does not generate any selected files. -n keeps expanding the file

 * tree arg until one of its files is selected, then skips to the next file

 * arg. when the user does not supply the file trees as command line args to

 * pax, they are read from stdin

 */

static FTS *ftsp = NULL;		/* current FTS handle */

static int ftsopts;			/* options to be used on fts_open */

static char *farray[2];			/* array for passing each arg to fts */

static FTREE *fthead = NULL;		/* head of linked list of file args */

static FTREE *fttail = NULL;		/* tail of linked list of file args */

static FTREE *ftcur = NULL;		/* current file arg being processed */

static FTSENT *ftent = NULL;		/* current file tree entry */

static int ftree_skip;			/* when set skip to next file arg */

static int ftree_arg(void);

static char *getpathname(char *, int);

/*

 * ftree_start()

 *	initialize the options passed to fts_open() during this run of pax

 *	options are based on the selection of pax options by the user

 *	fts_start() also calls fts_arg() to open the first valid file arg. We

 *	also attempt to reset directory access times when -t (tflag) is set.

 * Return:

 *	0 if there is at least one valid file arg to process, -1 otherwise

 */

int

ftree_start(void)

	/*

	 * set up the operation mode of fts, open the first file arg. We must

	 * use FTS_NOCHDIR, as the user may have to open multiple archives and

	 * if fts did a chdir off into the boondocks, we may create an archive

	 * volume in an place where the user did not expect to.

	 */

	/*

	 * optional user flags that effect file traversal

	 * -H command line symlink follow only (half follow)

	 * -L follow sylinks (logical)

	 * -P do not follow sylinks (physical). This is the default.

	 * -X do not cross over mount points

	 * -t preserve access times on files read.

	 * -n select only the first member of a file tree when a match is found

	 * -d do not extract subtrees rooted at a directory arg.

	 */

	else

	}

}

/*

 * ftree_add()

 *	add the arg to the linked list of files to process. Each will be

 *	processed by fts one at a time

 * Return:

 *	0 if added to the linked list, -1 if failed

 */

int

ftree_add(char *str, int chflg)

	FTREE *ft;

	int len;

	/*

	 * simple check for bad args

	 */

	}

	/*

	 * allocate FTREE node and add to the end of the linked list (args are

	 * processed in the same order they were passed to pax). Get rid of any

	 * trailing / the user may pass us. (watch out for / by itself).

	 */

	}

	}

}

/*

 * ftree_sel()

 *	this entry has been selected by pax. bump up reference count and handle

 *	-n and -d processing.

 */

void

ftree_sel(ARCHD *arcn)

	/*

	 * set reference bit for this pattern. This linked list is only used

	 * when file trees are supplied pax as args. The list is not used when

	 * the trees are read from stdin.

	 */

	/*

	 * if -n we are done with this arg, force a skip to the next arg when

	 * pax asks for the next file in next_file().

	 * if -d we tell fts only to match the directory (if the arg is a dir)

	 * and not the entire file tree rooted at that point.

	 */

		return;

}

/*

 * ftree_skipped_newer()

 *	file has been skipped because a newer file exists and -u/-D given

 */

void

ftree_skipped_newer(ARCHD *arcn)

{

	/* skipped due to -u/-D, mark accordingly */

}

/*

 * ftree_chk()

 *	called at end on pax execution. Prints all those file args that did not

 *	have a selected member (reference count still 0)

 */

void

ftree_chk(void)

	FTREE *ft;

	/*

	 * make sure all dir access times were reset.

	 */

	/*

	 * walk down list and check reference count. Print out those members

	 * that never had a match

	 */

			continue;

		}

	}

/*

 * ftree_arg()

 *	Get the next file arg for fts to process. Can be from either the linked

 *	list or read from stdin when the user did not them as args to pax. Each

 *	arg is processed until the first successful fts_open().

 * Return:

 *	0 when the next arg is ready to go, -1 if out of file args (or EOF on

 *	stdin).

 */

static int

ftree_arg(void)

	/*

	 * close off the current file tree

	 */

	}

	/*

	 * keep looping until we get a valid file tree to process. Stop when we

	 * reach the end of the list (or get an eof on stdin)

	 */

	for (;;) {

			/*

			 * the user didn't supply any args, get the file trees

			 * to process from stdin;

			 */

		} else {

			/*

			 * the user supplied the file args as arguments to pax

			 */

				/* First fchdir() back... */

					  "Can't fchdir to starting directory");

				}

					    ftcur->fname);

				}

				continue;

			} else

		}

		/*

		 * watch it, fts wants the file arg stored in a array of char

		 * ptrs, with the last one a null. we use a two element array

		 * and set farray[0] to point at the buffer with the file name

		 * in it. We cannot pass all the file args to fts at one shot

		 * as we need to keep a handle on which file arg generates what

		 * files (the -n and -d flags need this). If the open is

		 * successful, return a 0.

		 */

	}

}

/*

 * next_file()

 *	supplies the next file to process in the supplied archd structure.

 * Return:

 *	0 when contents of arcn have been set with the next file, -1 when done.

 */

int

next_file(ARCHD *arcn)

	int cnt;

	/*

	 * ftree_sel() might have set the ftree_skip flag if the user has the

	 * -n option and a file was selected from this file arg tree. (-n says

	 * only one member is matched for each pattern) ftree_skip being 1

	 * forces us to go to the next arg now.

	 */

		/*

		 * clear and go to next arg

		 */

	}

	/*

	 * loop until we get a valid file to process

	 */

	for (;;) {

			/*

			 * out of files in this tree, go to next arg, if none

			 * we are done

			 */

			continue;

		}

		/*

		 * handle each type of fts_read() flag

		 */

		case FTS_D:

		case FTS_DEFAULT:

		case FTS_F:

		case FTS_SL:

		case FTS_SLNONE:

			/*

			 * these are all ok

			 */

			break;

		case FTS_DP:

			/*

			 * already saw this directory. If the user wants file

			 * access times reset, we use this to restore the

			 * access time for this directory since this is the

			 * last time we will see it in this file subtree

			 * remember to force the time (this is -t on a read

			 * directory, not a created directory).

			 */

			    ftent->fts_statp->st_ino);

		case FTS_DC:

			/*

			 * fts claims a file system cycle

			 */

		case FTS_DNR:

			    "Unable to read directory %s", ftent->fts_path);

		case FTS_ERR:

			    "File system traversal error");

		case FTS_NS:

		case FTS_NSOK:

			    "Unable to access %s", ftent->fts_path);

		}

		/*

		 * ok got a file tree node to process. copy info into arcn

		 * structure (initialize as required)

		 */

		/*

		 * file type based set up and copy into the arcn struct

		 * SIDE NOTE:

		 * we try to reset the access time on all files and directories

		 * we may read when the -t flag is specified. files are reset

		 * when we close them after copying. we reset the directories

		 * when we are done with their file tree (we also clean up at

		 * end in case we cut short a file tree traversal). However

		 * there is no way to reset access times on symlinks.

		 */

		case S_IFDIR:

			    arcn->sb.st_ino, &arcn->sb.st_mtim,

			    &arcn->sb.st_atim);

		case S_IFCHR:

		case S_IFBLK:

		case S_IFREG:

			/*

			 * only regular files with have data to store on the

			 * archive. all others will store a zero length skip.

			 * the skip field is used by pax for actual data it has

			 * to read (or skip over).

			 */

		case S_IFLNK:

			/*

			 * have to read the symlink path from the file

			 */

			    PAXPATHLEN)) < 0) {

				    ftent->fts_path);

			}

			/*

			 * set link name length, watch out readlink does not

			 * NUL terminate the link path

			 */

		case S_IFSOCK:

			/*

			 * under BSD storing a socket is senseless but we will

			 * let the format specific write function make the

			 * decision of what to do with it.

			 */

		case S_IFIFO:

			break;

		}

		break;

	}

	/*

	 * copy file name, set file name length

	 */

}

/*

 * getpathname()

 *	Reads a pathname from stdin, handling NUL- or newline-termination.

 * Return:

 *	NULL at end of file, otherwise the NUL-terminated buffer.

 */

static char *

getpathname(char *buf, int buflen)

	char *bp, *ep;

	int ch, term;

		/*

		 * Read a NUL-terminated pathname, being especially

		 * paranoid about proper termination and pathname length.

		 */

					    "pathname at EOF");

			}

		}

		/* Too long - skip this path */

	} else {

		}

		/* Too long - skip this path */

	}

		continue;

}