xref: /minix/bin/pax/ftree.c (revision 85fee539)
1 /*	$NetBSD: ftree.c,v 1.42 2012/09/27 00:44:59 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 1992 Keith Muller.
5  * Copyright (c) 1992, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Keith Muller of the University of California, San Diego.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 /*-
37  * Copyright (c) 2001 The NetBSD Foundation, Inc.
38  * All rights reserved.
39  *
40  * This code is derived from software contributed to The NetBSD Foundation
41  * by Luke Mewburn of Wasabi Systems.
42  *
43  * Redistribution and use in source and binary forms, with or without
44  * modification, are permitted provided that the following conditions
45  * are met:
46  * 1. Redistributions of source code must retain the above copyright
47  *    notice, this list of conditions and the following disclaimer.
48  * 2. Redistributions in binary form must reproduce the above copyright
49  *    notice, this list of conditions and the following disclaimer in the
50  *    documentation and/or other materials provided with the distribution.
51  *
52  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
53  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
54  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
55  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
56  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
57  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
58  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
59  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
60  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
61  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
62  * POSSIBILITY OF SUCH DAMAGE.
63  */
64 
65 #if HAVE_NBTOOL_CONFIG_H
66 #include "nbtool_config.h"
67 #endif
68 
69 #include <sys/cdefs.h>
70 #if !defined(lint)
71 #if 0
72 static char sccsid[] = "@(#)ftree.c	8.2 (Berkeley) 4/18/94";
73 #else
74 __RCSID("$NetBSD: ftree.c,v 1.42 2012/09/27 00:44:59 christos Exp $");
75 #endif
76 #endif /* not lint */
77 
78 #include <sys/types.h>
79 #include <sys/time.h>
80 #include <sys/stat.h>
81 #include <sys/param.h>
82 #include <ctype.h>
83 #include <errno.h>
84 #include <fts.h>
85 #include <stdio.h>
86 #include <stdlib.h>
87 #include <string.h>
88 #include <unistd.h>
89 #include "pax.h"
90 #include "ftree.h"
91 #include "extern.h"
92 #include "options.h"
93 #ifndef SMALL
94 #include "mtree.h"
95 #endif	/* SMALL */
96 
97 /*
98  * routines to interface with the fts library function.
99  *
100  * file args supplied to pax are stored on a single linked list (of type FTREE)
101  * and given to fts to be processed one at a time. pax "selects" files from
102  * the expansion of each arg into the corresponding file tree (if the arg is a
103  * directory, otherwise the node itself is just passed to pax). The selection
104  * is modified by the -n and -u flags. The user is informed when a specific
105  * file arg does not generate any selected files. -n keeps expanding the file
106  * tree arg until one of its files is selected, then skips to the next file
107  * arg. when the user does not supply the file trees as command line args to
108  * pax, they are read from stdin
109  */
110 
111 static FTS *ftsp = NULL;		/* current FTS handle */
112 static int ftsopts;			/* options to be used on fts_open */
113 static char *farray[2];			/* array for passing each arg to fts */
114 static FTREE *fthead = NULL;		/* head of linked list of file args */
115 static FTREE *fttail = NULL;		/* tail of linked list of file args */
116 static FTREE *ftcur = NULL;		/* current file arg being processed */
117 static FTSENT *ftent = NULL;		/* current file tree entry */
118 static int ftree_skip;			/* when set skip to next file arg */
119 #ifndef SMALL
120 static NODE *ftnode = NULL;		/* mtree(8) specfile; used by -M */
121 #endif	/* SMALL */
122 
123 static int ftree_arg(void);
124 
125 #define	FTS_ERRNO(x)	(x)->fts_errno
126 
127 /*
128  * ftree_start()
129  *	initialize the options passed to fts_open() during this run of pax
130  *	options are based on the selection of pax options by the user
131  *	fts_start() also calls fts_arg() to open the first valid file arg. We
132  *	also attempt to reset directory access times when -t (tflag) is set.
133  * Return:
134  *	0 if there is at least one valid file arg to process, -1 otherwise
135  */
136 
137 int
ftree_start(void)138 ftree_start(void)
139 {
140 
141 #ifndef SMALL
142 	/*
143 	 * if -M is given, the list of filenames on stdin is actually
144 	 * an mtree(8) specfile, so parse the specfile into a NODE *
145 	 * tree at ftnode, for use by next_file()
146 	 */
147 	if (Mflag) {
148 		if (fthead != NULL) {
149 			tty_warn(1,
150 	    "The -M flag is only supported when reading file list from stdin");
151 			return -1;
152 		}
153 		ftnode = spec(stdin);
154 		if (ftnode != NULL &&
155 		    (ftnode->type != F_DIR || strcmp(ftnode->name, ".") != 0)) {
156 			tty_warn(1,
157 			    "First node of specfile is not `.' directory");
158 			return -1;
159 		}
160 		return 0;
161 	}
162 #endif	/* SMALL */
163 
164 	/*
165 	 * set up the operation mode of fts, open the first file arg. We must
166 	 * use FTS_NOCHDIR, as the user may have to open multiple archives and
167 	 * if fts did a chdir off into the boondocks, we may create an archive
168 	 * volume in an place where the user did not expect to.
169 	 */
170 	ftsopts = FTS_NOCHDIR;
171 
172 	/*
173 	 * optional user flags that effect file traversal
174 	 * -H command line symlink follow only (half follow)
175 	 * -L follow sylinks (logical)
176 	 * -P do not follow sylinks (physical). This is the default.
177 	 * -X do not cross over mount points
178 	 * -t preserve access times on files read.
179 	 * -n select only the first member of a file tree when a match is found
180 	 * -d do not extract subtrees rooted at a directory arg.
181 	 */
182 	if (Lflag)
183 		ftsopts |= FTS_LOGICAL;
184 	else
185 		ftsopts |= FTS_PHYSICAL;
186 	if (Hflag)
187 		ftsopts |= FTS_COMFOLLOW;
188 	if (Xflag)
189 		ftsopts |= FTS_XDEV;
190 
191 	if ((fthead == NULL) && ((farray[0] = malloc(PAXPATHLEN+2)) == NULL)) {
192 		tty_warn(1, "Unable to allocate memory for file name buffer");
193 		return -1;
194 	}
195 
196 	if (ftree_arg() < 0)
197 		return -1;
198 	if (tflag && (atdir_start() < 0))
199 		return -1;
200 	return 0;
201 }
202 
203 /*
204  * ftree_add()
205  *	add the arg to the linked list of files to process. Each will be
206  *	processed by fts one at a time
207  * Return:
208  *	0 if added to the linked list, -1 if failed
209  */
210 
211 int
ftree_add(char * str,int isdir)212 ftree_add(char *str, int isdir)
213 {
214 	FTREE *ft;
215 	int len;
216 
217 	/*
218 	 * simple check for bad args
219 	 */
220 	if ((str == NULL) || (*str == '\0')) {
221 		tty_warn(0, "Invalid file name argument");
222 		return -1;
223 	}
224 
225 	/*
226 	 * allocate FTREE node and add to the end of the linked list (args are
227 	 * processed in the same order they were passed to pax). Get rid of any
228 	 * trailing / the user may pass us. (watch out for / by itself).
229 	 */
230 	if ((ft = (FTREE *)malloc(sizeof(FTREE))) == NULL) {
231 		tty_warn(0, "Unable to allocate memory for filename");
232 		return -1;
233 	}
234 
235 	if (((len = strlen(str) - 1) > 0) && (str[len] == '/'))
236 		str[len] = '\0';
237 	ft->fname = str;
238 	ft->refcnt = -isdir;
239 	ft->fow = NULL;
240 	if (fthead == NULL) {
241 		fttail = fthead = ft;
242 		return 0;
243 	}
244 	fttail->fow = ft;
245 	fttail = ft;
246 	return 0;
247 }
248 
249 /*
250  * ftree_sel()
251  *	this entry has been selected by pax. bump up reference count and handle
252  *	-n and -d processing.
253  */
254 
255 void
ftree_sel(ARCHD * arcn)256 ftree_sel(ARCHD *arcn)
257 {
258 	/*
259 	 * set reference bit for this pattern. This linked list is only used
260 	 * when file trees are supplied pax as args. The list is not used when
261 	 * the trees are read from stdin.
262 	 */
263 	if (ftcur != NULL)
264 		ftcur->refcnt = 1;
265 
266 	/*
267 	 * if -n we are done with this arg, force a skip to the next arg when
268 	 * pax asks for the next file in next_file().
269 	 * if -M we don't use fts(3), so the rest of this function is moot.
270 	 * if -d we tell fts only to match the directory (if the arg is a dir)
271 	 * and not the entire file tree rooted at that point.
272 	 */
273 	if (nflag)
274 		ftree_skip = 1;
275 
276 	if (Mflag || !dflag || (arcn->type != PAX_DIR))
277 		return;
278 
279 	if (ftent != NULL)
280 		(void)fts_set(ftsp, ftent, FTS_SKIP);
281 }
282 
283 /*
284  * ftree_chk()
285  *	called at end on pax execution. Prints all those file args that did not
286  *	have a selected member (reference count still 0)
287  */
288 
289 void
ftree_chk(void)290 ftree_chk(void)
291 {
292 	FTREE *ft;
293 	int wban = 0;
294 
295 	/*
296 	 * make sure all dir access times were reset.
297 	 */
298 	if (tflag)
299 		atdir_end();
300 
301 	/*
302 	 * walk down list and check reference count. Print out those members
303 	 * that never had a match
304 	 */
305 	for (ft = fthead; ft != NULL; ft = ft->fow) {
306 		if (ft->refcnt != 0)
307 			continue;
308 		if (wban == 0) {
309 			tty_warn(1,
310 			    "WARNING! These file names were not selected:");
311 			++wban;
312 		}
313 		(void)fprintf(stderr, "%s\n", ft->fname);
314 	}
315 }
316 
317 /*
318  * ftree_arg()
319  *	Get the next file arg for fts to process. Can be from either the linked
320  *	list or read from stdin when the user did not them as args to pax. Each
321  *	arg is processed until the first successful fts_open().
322  * Return:
323  *	0 when the next arg is ready to go, -1 if out of file args (or EOF on
324  *	stdin).
325  */
326 
327 static int
ftree_arg(void)328 ftree_arg(void)
329 {
330 	/*
331 	 * close off the current file tree
332 	 */
333 	if (ftsp != NULL) {
334 		(void)fts_close(ftsp);
335 		ftsp = NULL;
336 		ftent = NULL;
337 	}
338 
339 	/*
340 	 * keep looping until we get a valid file tree to process. Stop when we
341 	 * reach the end of the list (or get an eof on stdin)
342 	 */
343 	for(;;) {
344 		if (fthead == NULL) {
345 			int i, c = EOF;
346 			/*
347 			 * the user didn't supply any args, get the file trees
348 			 * to process from stdin;
349 			 */
350 			for (i = 0; i < PAXPATHLEN + 2;) {
351 				c = getchar();
352 				if (c == EOF)
353 					break;
354 				else if (c == sep) {
355 					if (i != 0)
356 						break;
357 				} else
358 					farray[0][i++] = c;
359 			}
360 			if (i == 0)
361 				return -1;
362 			farray[0][i] = '\0';
363 		} else {
364 			/*
365 			 * the user supplied the file args as arguments to pax
366 			 */
367 			if (ftcur == NULL)
368 				ftcur = fthead;
369 			else if ((ftcur = ftcur->fow) == NULL)
370 				return -1;
371 
372 			if (ftcur->refcnt < 0) {
373 				/*
374 				 * chdir entry.
375 				 * Change directory and retry loop.
376 				 */
377 				if (ar_dochdir(ftcur->fname))
378 					return (-1);
379 				continue;
380 			}
381 			farray[0] = ftcur->fname;
382 		}
383 
384 		/*
385 		 * watch it, fts wants the file arg stored in a array of char
386 		 * ptrs, with the last one a null. we use a two element array
387 		 * and set farray[0] to point at the buffer with the file name
388 		 * in it. We cannot pass all the file args to fts at one shot
389 		 * as we need to keep a handle on which file arg generates what
390 		 * files (the -n and -d flags need this). If the open is
391 		 * successful, return a 0.
392 		 */
393 		if ((ftsp = fts_open(farray, ftsopts, NULL)) != NULL)
394 			break;
395 	}
396 	return 0;
397 }
398 
399 /*
400  * next_file()
401  *	supplies the next file to process in the supplied archd structure.
402  * Return:
403  *	0 when contents of arcn have been set with the next file, -1 when done.
404  */
405 
406 int
next_file(ARCHD * arcn)407 next_file(ARCHD *arcn)
408 {
409 #ifndef SMALL
410 	static	char	curdir[PAXPATHLEN+2], curpath[PAXPATHLEN+2];
411 	static	int	curdirlen;
412 
413 	struct stat	statbuf;
414 	FTSENT		Mftent;
415 #endif	/* SMALL */
416 	int		cnt;
417 	time_t		atime, mtime;
418 	char		*curlink;
419 #define MFTENT_DUMMY_DEV	UINT_MAX
420 
421 	curlink = NULL;
422 #ifndef SMALL
423 	/*
424 	 * if parsing an mtree(8) specfile, build up `dummy' ftsent
425 	 * from specfile info, and jump below to complete setup of arcn.
426 	 */
427 	if (Mflag) {
428 		int	skipoptional;
429 
430  next_ftnode:
431 		skipoptional = 0;
432 		if (ftnode == NULL)		/* tree is empty */
433 			return (-1);
434 
435 						/* get current name */
436 		if (snprintf(curpath, sizeof(curpath), "%s%s%s",
437 		    curdir, curdirlen ? "/" : "", ftnode->name)
438 		    >= (int)sizeof(curpath)) {
439 			tty_warn(1, "line %lu: %s: %s", (u_long)ftnode->lineno,
440 			    curdir, strerror(ENAMETOOLONG));
441 			return (-1);
442 		}
443 		ftnode->flags |= F_VISIT;	/* mark node visited */
444 
445 						/* construct dummy FTSENT */
446 		Mftent.fts_path = curpath;
447 		Mftent.fts_statp = &statbuf;
448 		Mftent.fts_pointer = ftnode;
449 		ftent = &Mftent;
450 						/* look for existing file */
451 		if (lstat(Mftent.fts_path, &statbuf) == -1) {
452 			if (ftnode->flags & F_OPT)
453 				skipoptional = 1;
454 
455 						/* missing: fake up stat info */
456 			memset(&statbuf, 0, sizeof(statbuf));
457 			statbuf.st_dev = MFTENT_DUMMY_DEV;
458 			statbuf.st_ino = ftnode->lineno;
459 			statbuf.st_size = 0;
460 #define NODETEST(t, m)							\
461 			if (!(t)) {					\
462 				tty_warn(1, "line %lu: %s: %s not specified", \
463 				    (u_long)ftnode->lineno,		\
464 				    ftent->fts_path, m);		\
465 				return -1;				\
466 			}
467 			statbuf.st_mode = nodetoino(ftnode->type);
468 			NODETEST(ftnode->flags & F_TYPE, "type");
469 			NODETEST(ftnode->flags & F_MODE, "mode");
470 			if (!(ftnode->flags & F_TIME))
471 				statbuf.st_mtime = starttime;
472 			NODETEST(ftnode->flags & (F_GID | F_GNAME), "group");
473 			NODETEST(ftnode->flags & (F_UID | F_UNAME), "user");
474 			if (ftnode->type == F_BLOCK || ftnode->type == F_CHAR)
475 				NODETEST(ftnode->flags & F_DEV,
476 				    "device number");
477 			if (ftnode->type == F_LINK)
478 				NODETEST(ftnode->flags & F_SLINK, "symlink");
479 			/* don't require F_FLAGS or F_SIZE */
480 #undef NODETEST
481 		} else {
482 			if (ftnode->flags & F_TYPE && nodetoino(ftnode->type)
483 			    != (statbuf.st_mode & S_IFMT)) {
484 				tty_warn(1,
485 			    "line %lu: %s: type mismatch: specfile %s, tree %s",
486 				    (u_long)ftnode->lineno, ftent->fts_path,
487 				    inotype(nodetoino(ftnode->type)),
488 				    inotype(statbuf.st_mode));
489 				return -1;
490 			}
491 			if (ftnode->type == F_DIR && (ftnode->flags & F_OPT))
492 				skipoptional = 1;
493 		}
494 		/*
495 		 * override settings with those from specfile
496 		 */
497 		if (ftnode->flags & F_MODE) {
498 			statbuf.st_mode &= ~ALLPERMS;
499 			statbuf.st_mode |= (ftnode->st_mode & ALLPERMS);
500 		}
501 		if (ftnode->flags & (F_GID | F_GNAME))
502 			statbuf.st_gid = ftnode->st_gid;
503 		if (ftnode->flags & (F_UID | F_UNAME))
504 			statbuf.st_uid = ftnode->st_uid;
505 #if HAVE_STRUCT_STAT_ST_FLAGS
506 		if (ftnode->flags & F_FLAGS)
507 			statbuf.st_flags = ftnode->st_flags;
508 #endif
509 		if (ftnode->flags & F_TIME)
510 #if BSD4_4 && !HAVE_NBTOOL_CONFIG_H
511 			statbuf.st_mtimespec = ftnode->st_mtimespec;
512 #else
513 			statbuf.st_mtime = ftnode->st_mtimespec.tv_sec;
514 #endif
515 		if (ftnode->flags & F_DEV)
516 			statbuf.st_rdev = ftnode->st_rdev;
517 		if (ftnode->flags & F_SLINK)
518 			curlink = ftnode->slink;
519 				/* ignore F_SIZE */
520 
521 		/*
522 		 * find next node
523 		 */
524 		if (ftnode->type == F_DIR && ftnode->child != NULL) {
525 					/* directory with unseen child */
526 			ftnode = ftnode->child;
527 			curdirlen = strlcpy(curdir, curpath, sizeof(curdir));
528 		} else do {
529 			if (ftnode->next != NULL) {
530 					/* next node at current level */
531 				ftnode = ftnode->next;
532 			} else {	/* move back to parent */
533 					/* reset time only on first cd.. */
534 				if (Mftent.fts_pointer == ftnode && tflag &&
535 				    (get_atdir(MFTENT_DUMMY_DEV, ftnode->lineno,
536 				    &mtime, &atime) == 0)) {
537 					set_ftime(ftent->fts_path,
538 					    mtime, atime, 1, 0);
539 				}
540 				ftnode = ftnode->parent;
541 				if (ftnode->parent == ftnode)
542 					ftnode = NULL;
543 				else {
544 					curdirlen -= strlen(ftnode->name) + 1;
545 					curdir[curdirlen] = '\0';
546 				}
547 			}
548 		} while (ftnode != NULL && ftnode->flags & F_VISIT);
549 		if (skipoptional)	/* skip optional entries */
550 			goto next_ftnode;
551 		goto got_ftent;
552 	}
553 #endif	/* SMALL */
554 
555 	/*
556 	 * ftree_sel() might have set the ftree_skip flag if the user has the
557 	 * -n option and a file was selected from this file arg tree. (-n says
558 	 * only one member is matched for each pattern) ftree_skip being 1
559 	 * forces us to go to the next arg now.
560 	 */
561 	if (ftree_skip) {
562 		/*
563 		 * clear and go to next arg
564 		 */
565 		ftree_skip = 0;
566 		if (ftree_arg() < 0)
567 			return -1;
568 	}
569 
570 	if (ftsp == NULL)
571 		return -1;
572 	/*
573 	 * loop until we get a valid file to process
574 	 */
575 	for(;;) {
576 		if ((ftent = fts_read(ftsp)) == NULL) {
577 			/*
578 			 * out of files in this tree, go to next arg, if none
579 			 * we are done
580 			 */
581 			if (ftree_arg() < 0)
582 				return -1;
583 			continue;
584 		}
585 
586 		/*
587 		 * handle each type of fts_read() flag
588 		 */
589 		switch(ftent->fts_info) {
590 		case FTS_D:
591 		case FTS_DEFAULT:
592 		case FTS_F:
593 		case FTS_SL:
594 		case FTS_SLNONE:
595 			/*
596 			 * these are all ok
597 			 */
598 			break;
599 		case FTS_DP:
600 			/*
601 			 * already saw this directory. If the user wants file
602 			 * access times reset, we use this to restore the
603 			 * access time for this directory since this is the
604 			 * last time we will see it in this file subtree
605 			 * remember to force the time (this is -t on a read
606 			 * directory, not a created directory).
607 			 */
608 			if (!tflag || (get_atdir(
609 			    ftent->fts_statp->st_dev, ftent->fts_statp->st_ino,
610 			    &mtime, &atime) < 0))
611 				continue;
612 			set_ftime(ftent->fts_path, mtime, atime, 1, 0);
613 			continue;
614 		case FTS_DC:
615 			/*
616 			 * fts claims a file system cycle
617 			 */
618 			tty_warn(1,"File system cycle found at %s",
619 			    ftent->fts_path);
620 			continue;
621 		case FTS_DNR:
622 			syswarn(1, FTS_ERRNO(ftent),
623 			    "Unable to read directory %s", ftent->fts_path);
624 			continue;
625 		case FTS_ERR:
626 			syswarn(1, FTS_ERRNO(ftent),
627 			    "File system traversal error");
628 			continue;
629 		case FTS_NS:
630 		case FTS_NSOK:
631 			syswarn(1, FTS_ERRNO(ftent),
632 			    "Unable to access %s", ftent->fts_path);
633 			continue;
634 		}
635 
636 #ifndef SMALL
637  got_ftent:
638 #endif	/* SMALL */
639 		/*
640 		 * ok got a file tree node to process. copy info into arcn
641 		 * structure (initialize as required)
642 		 */
643 		arcn->skip = 0;
644 		arcn->pad = 0;
645 		arcn->ln_nlen = 0;
646 		arcn->ln_name[0] = '\0';
647 		arcn->sb = *(ftent->fts_statp);
648 
649 		/*
650 		 * file type based set up and copy into the arcn struct
651 		 * SIDE NOTE:
652 		 * we try to reset the access time on all files and directories
653 		 * we may read when the -t flag is specified. files are reset
654 		 * when we close them after copying. we reset the directories
655 		 * when we are done with their file tree (we also clean up at
656 		 * end in case we cut short a file tree traversal). However
657 		 * there is no way to reset access times on symlinks.
658 		 */
659 		switch(S_IFMT & arcn->sb.st_mode) {
660 		case S_IFDIR:
661 			arcn->type = PAX_DIR;
662 			if (!tflag)
663 				break;
664 			add_atdir(ftent->fts_path, arcn->sb.st_dev,
665 			    arcn->sb.st_ino, arcn->sb.st_mtime,
666 			    arcn->sb.st_atime);
667 			break;
668 		case S_IFCHR:
669 			arcn->type = PAX_CHR;
670 			break;
671 		case S_IFBLK:
672 			arcn->type = PAX_BLK;
673 			break;
674 		case S_IFREG:
675 			/*
676 			 * only regular files with have data to store on the
677 			 * archive. all others will store a zero length skip.
678 			 * the skip field is used by pax for actual data it has
679 			 * to read (or skip over).
680 			 */
681 			arcn->type = PAX_REG;
682 			arcn->skip = arcn->sb.st_size;
683 			break;
684 		case S_IFLNK:
685 			arcn->type = PAX_SLK;
686 			if (curlink != NULL) {
687 				cnt = strlcpy(arcn->ln_name, curlink,
688 				    sizeof(arcn->ln_name));
689 			/*
690 			 * have to read the symlink path from the file
691 			 */
692 			} else if ((cnt =
693 			    readlink(ftent->fts_path, arcn->ln_name,
694 			    sizeof(arcn->ln_name) - 1)) < 0) {
695 				syswarn(1, errno, "Unable to read symlink %s",
696 				    ftent->fts_path);
697 				continue;
698 			}
699 			/*
700 			 * set link name length, watch out readlink does not
701 			 * always null terminate the link path
702 			 */
703 			arcn->ln_name[cnt] = '\0';
704 			arcn->ln_nlen = cnt;
705 			break;
706 #ifdef S_IFSOCK
707 		case S_IFSOCK:
708 			/*
709 			 * under BSD storing a socket is senseless but we will
710 			 * let the format specific write function make the
711 			 * decision of what to do with it.
712 			 */
713 			arcn->type = PAX_SCK;
714 			break;
715 #endif
716 		case S_IFIFO:
717 			arcn->type = PAX_FIF;
718 			break;
719 		}
720 		break;
721 	}
722 
723 	/*
724 	 * copy file name, set file name length
725 	 */
726 	arcn->nlen = strlcpy(arcn->name, ftent->fts_path, sizeof(arcn->name));
727 	arcn->org_name = arcn->fts_name;
728 	strlcpy(arcn->fts_name, ftent->fts_path, sizeof arcn->fts_name);
729 	if (strcmp(NM_CPIO, argv0) == 0) {
730 		/*
731 		 * cpio does *not* descend directories listed in the
732 		 * arguments, unlike pax/tar, so needs special handling
733 		 * here.  failure to do so results in massive amounts
734 		 * of duplicated files in the output. We kill fts after
735 		 * the first name is extracted, what a waste.
736 		 */
737 		ftcur->refcnt = 1;
738 		(void)ftree_arg();
739 	}
740 	return 0;
741 }
742