xref: /freebsd/sbin/dump/main.c (revision 6990ffd8a95caaba6858ad44ff1b3157d1efba8f)
1 /*-
2  * Copyright (c) 1980, 1991, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. 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.
20  *
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
31  * SUCH DAMAGE.
32  */
33 
34 #ifndef lint
35 static const char copyright[] =
36 "@(#) Copyright (c) 1980, 1991, 1993, 1994\n\
37 	The Regents of the University of California.  All rights reserved.\n";
38 #endif /* not lint */
39 
40 #ifndef lint
41 #if 0
42 static char sccsid[] = "@(#)main.c	8.6 (Berkeley) 5/1/95";
43 #endif
44 static const char rcsid[] =
45   "$FreeBSD$";
46 #endif /* not lint */
47 
48 #include <sys/param.h>
49 #include <sys/stat.h>
50 #include <sys/time.h>
51 #ifdef sunos
52 #include <sys/vnode.h>
53 
54 #include <ufs/inode.h>
55 #include <ufs/fs.h>
56 #else
57 #include <ufs/ufs/dinode.h>
58 #include <ufs/ffs/fs.h>
59 #endif
60 
61 #include <protocols/dumprestore.h>
62 
63 #include <ctype.h>
64 #include <err.h>
65 #include <fcntl.h>
66 #include <fstab.h>
67 #include <signal.h>
68 #include <stdio.h>
69 #include <stdlib.h>
70 #include <string.h>
71 #include <unistd.h>
72 
73 #include "dump.h"
74 #include "pathnames.h"
75 
76 #ifndef SBOFF
77 #define SBOFF (SBLOCK * DEV_BSIZE)
78 #endif
79 
80 int	notify = 0;	/* notify operator flag */
81 int	blockswritten = 0;	/* number of blocks written on current tape */
82 int	tapeno = 0;	/* current tape number */
83 int	density = 0;	/* density in bytes/0.1" " <- this is for hilit19 */
84 int	ntrec = NTREC;	/* # tape blocks in each tape record */
85 int	cartridge = 0;	/* Assume non-cartridge tape */
86 int	dokerberos = 0;	/* Use Kerberos authentication */
87 long	dev_bsize = 1;	/* recalculated below */
88 long	blocksperfile;	/* output blocks per file */
89 char	*host = NULL;	/* remote host (if any) */
90 
91 static long numarg __P((char *, long, long));
92 static void obsolete __P((int *, char **[]));
93 static void usage __P((void));
94 
95 int
96 main(argc, argv)
97 	int argc;
98 	char *argv[];
99 {
100 	register ino_t ino;
101 	register int dirty;
102 	register struct dinode *dp;
103 	register struct	fstab *dt;
104 	register char *map;
105 	register int ch;
106 	int i, anydirskipped, bflag = 0, Tflag = 0, honorlevel = 1;
107 	ino_t maxino;
108 
109 	spcl.c_date = 0;
110 	(void)time((time_t *)&spcl.c_date);
111 
112 	tsize = 0;	/* Default later, based on 'c' option for cart tapes */
113 	if ((tape = getenv("TAPE")) == NULL)
114 		tape = _PATH_DEFTAPE;
115 	dumpdates = _PATH_DUMPDATES;
116 	temp = _PATH_DTMP;
117 	if (TP_BSIZE / DEV_BSIZE == 0 || TP_BSIZE % DEV_BSIZE != 0)
118 		quit("TP_BSIZE must be a multiple of DEV_BSIZE\n");
119 	level = '0';
120 
121 	if (argc < 2)
122 		usage();
123 
124 	obsolete(&argc, &argv);
125 #ifdef KERBEROS
126 #define optstring "0123456789aB:b:cd:f:h:kns:T:uWwD:"
127 #else
128 #define optstring "0123456789aB:b:cd:f:h:ns:T:uWwD:"
129 #endif
130 	while ((ch = getopt(argc, argv, optstring)) != -1)
131 #undef optstring
132 		switch (ch) {
133 		/* dump level */
134 		case '0': case '1': case '2': case '3': case '4':
135 		case '5': case '6': case '7': case '8': case '9':
136 			level = ch;
137 			break;
138 
139 		case 'a':		/* `auto-size', Write to EOM. */
140 			unlimited = 1;
141 			break;
142 
143 		case 'B':		/* blocks per output file */
144 			blocksperfile = numarg("number of blocks per file",
145 			    1L, 0L);
146 			break;
147 
148 		case 'b':		/* blocks per tape write */
149 			ntrec = numarg("number of blocks per write",
150 			    1L, 1000L);
151 			break;
152 
153 		case 'c':		/* Tape is cart. not 9-track */
154 			cartridge = 1;
155 			break;
156 
157 		case 'd':		/* density, in bits per inch */
158 			density = numarg("density", 10L, 327670L) / 10;
159 			if (density >= 625 && !bflag)
160 				ntrec = HIGHDENSITYTREC;
161 			break;
162 
163 		case 'f':		/* output file */
164 			tape = optarg;
165 			break;
166 
167 		case 'D':
168 			dumpdates = optarg;
169 			break;
170 
171 		case 'h':
172 			honorlevel = numarg("honor level", 0L, 10L);
173 			break;
174 
175 #ifdef KERBEROS
176 		case 'k':
177 			dokerberos = 1;
178 			break;
179 #endif
180 
181 		case 'n':		/* notify operators */
182 			notify = 1;
183 			break;
184 
185 		case 's':		/* tape size, feet */
186 			tsize = numarg("tape size", 1L, 0L) * 12 * 10;
187 			break;
188 
189 		case 'T':		/* time of last dump */
190 			spcl.c_ddate = unctime(optarg);
191 			if (spcl.c_ddate < 0) {
192 				(void)fprintf(stderr, "bad time \"%s\"\n",
193 				    optarg);
194 				exit(X_STARTUP);
195 			}
196 			Tflag = 1;
197 			lastlevel = '?';
198 			break;
199 
200 		case 'u':		/* update /etc/dumpdates */
201 			uflag = 1;
202 			break;
203 
204 		case 'W':		/* what to do */
205 		case 'w':
206 			lastdump(ch);
207 			exit(X_FINOK);	/* do nothing else */
208 
209 		default:
210 			usage();
211 		}
212 	argc -= optind;
213 	argv += optind;
214 
215 	if (argc < 1) {
216 		(void)fprintf(stderr, "Must specify disk or filesystem\n");
217 		exit(X_STARTUP);
218 	}
219 	disk = *argv++;
220 	argc--;
221 	if (argc >= 1) {
222 		(void)fprintf(stderr, "Unknown arguments to dump:");
223 		while (argc--)
224 			(void)fprintf(stderr, " %s", *argv++);
225 		(void)fprintf(stderr, "\n");
226 		exit(X_STARTUP);
227 	}
228 	if (Tflag && uflag) {
229 	        (void)fprintf(stderr,
230 		    "You cannot use the T and u flags together.\n");
231 		exit(X_STARTUP);
232 	}
233 	if (strcmp(tape, "-") == 0) {
234 		pipeout++;
235 		tape = "standard output";
236 	}
237 
238 	if (blocksperfile)
239 		blocksperfile = blocksperfile / ntrec * ntrec; /* round down */
240 	else if (!unlimited) {
241 		/*
242 		 * Determine how to default tape size and density
243 		 *
244 		 *         	density				tape size
245 		 * 9-track	1600 bpi (160 bytes/.1")	2300 ft.
246 		 * 9-track	6250 bpi (625 bytes/.1")	2300 ft.
247 		 * cartridge	8000 bpi (100 bytes/.1")	1700 ft.
248 		 *						(450*4 - slop)
249 		 * hilit19 hits again: "
250 		 */
251 		if (density == 0)
252 			density = cartridge ? 100 : 160;
253 		if (tsize == 0)
254 			tsize = cartridge ? 1700L*120L : 2300L*120L;
255 	}
256 
257 	if (strchr(tape, ':')) {
258 		host = tape;
259 		tape = strchr(host, ':');
260 		*tape++ = '\0';
261 #ifdef RDUMP
262 		if (index(tape, '\n')) {
263 		    (void)fprintf(stderr, "invalid characters in tape\n");
264 		    exit(X_STARTUP);
265 		}
266 		if (rmthost(host) == 0)
267 			exit(X_STARTUP);
268 #else
269 		(void)fprintf(stderr, "remote dump not enabled\n");
270 		exit(X_STARTUP);
271 #endif
272 	}
273 	(void)setuid(getuid()); /* rmthost() is the only reason to be setuid */
274 
275 	if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
276 		signal(SIGHUP, sig);
277 	if (signal(SIGTRAP, SIG_IGN) != SIG_IGN)
278 		signal(SIGTRAP, sig);
279 	if (signal(SIGFPE, SIG_IGN) != SIG_IGN)
280 		signal(SIGFPE, sig);
281 	if (signal(SIGBUS, SIG_IGN) != SIG_IGN)
282 		signal(SIGBUS, sig);
283 	if (signal(SIGSEGV, SIG_IGN) != SIG_IGN)
284 		signal(SIGSEGV, sig);
285 	if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
286 		signal(SIGTERM, sig);
287 	if (signal(SIGINT, interrupt) == SIG_IGN)
288 		signal(SIGINT, SIG_IGN);
289 
290 	getfstab();		/* /etc/fstab snarfed */
291 	/*
292 	 *	disk can be either the full special file name,
293 	 *	the suffix of the special file name,
294 	 *	the special name missing the leading '/',
295 	 *	the file system name with or without the leading '/'.
296 	 */
297 	dt = fstabsearch(disk);
298 	if (dt != NULL) {
299 		disk = rawname(dt->fs_spec);
300 		(void)strncpy(spcl.c_dev, dt->fs_spec, NAMELEN);
301 		(void)strncpy(spcl.c_filesys, dt->fs_file, NAMELEN);
302 	} else {
303 		(void)strncpy(spcl.c_dev, disk, NAMELEN);
304 		(void)strncpy(spcl.c_filesys, "an unlisted file system",
305 		    NAMELEN);
306 	}
307 	spcl.c_dev[NAMELEN-1]='\0';
308 	spcl.c_filesys[NAMELEN-1]='\0';
309 	(void)strcpy(spcl.c_label, "none");
310 	(void)gethostname(spcl.c_host, NAMELEN);
311 	spcl.c_level = level - '0';
312 	spcl.c_type = TS_TAPE;
313 	if (!Tflag)
314 	        getdumptime();		/* /etc/dumpdates snarfed */
315 
316 	msg("Date of this level %c dump: %s", level,
317 		spcl.c_date == 0 ? "the epoch\n" : ctime(&spcl.c_date));
318  	msg("Date of last level %c dump: %s", lastlevel,
319 		spcl.c_ddate == 0 ? "the epoch\n" : ctime(&spcl.c_ddate));
320 	msg("Dumping %s ", disk);
321 	if (dt != NULL)
322 		msgtail("(%s) ", dt->fs_file);
323 	if (host)
324 		msgtail("to %s on host %s\n", tape, host);
325 	else
326 		msgtail("to %s\n", tape);
327 
328 	if ((diskfd = open(disk, O_RDONLY)) < 0) {
329 		msg("Cannot open %s\n", disk);
330 		exit(X_STARTUP);
331 	}
332 	sync();
333 	sblock = (struct fs *)sblock_buf;
334 	bread(SBOFF, (char *) sblock, SBSIZE);
335 	if (sblock->fs_magic != FS_MAGIC)
336 		quit("bad sblock magic number\n");
337 	dev_bsize = sblock->fs_fsize / fsbtodb(sblock, 1);
338 	dev_bshift = ffs(dev_bsize) - 1;
339 	if (dev_bsize != (1 << dev_bshift))
340 		quit("dev_bsize (%d) is not a power of 2", dev_bsize);
341 	tp_bshift = ffs(TP_BSIZE) - 1;
342 	if (TP_BSIZE != (1 << tp_bshift))
343 		quit("TP_BSIZE (%d) is not a power of 2", TP_BSIZE);
344 #ifdef FS_44INODEFMT
345 	if (sblock->fs_inodefmt >= FS_44INODEFMT)
346 		spcl.c_flags |= DR_NEWINODEFMT;
347 #endif
348 	maxino = sblock->fs_ipg * sblock->fs_ncg;
349 	mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);
350 	usedinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
351 	dumpdirmap = (char *)calloc((unsigned) mapsize, sizeof(char));
352 	dumpinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
353 	tapesize = 3 * (howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
354 
355 	nonodump = spcl.c_level < honorlevel;
356 
357 	msg("mapping (Pass I) [regular files]\n");
358 	anydirskipped = mapfiles(maxino, &tapesize);
359 
360 	msg("mapping (Pass II) [directories]\n");
361 	while (anydirskipped) {
362 		anydirskipped = mapdirs(maxino, &tapesize);
363 	}
364 
365 	if (pipeout || unlimited) {
366 		tapesize += 10;	/* 10 trailer blocks */
367 		msg("estimated %ld tape blocks.\n", tapesize);
368 	} else {
369 		double fetapes;
370 
371 		if (blocksperfile)
372 			fetapes = (double) tapesize / blocksperfile;
373 		else if (cartridge) {
374 			/* Estimate number of tapes, assuming streaming stops at
375 			   the end of each block written, and not in mid-block.
376 			   Assume no erroneous blocks; this can be compensated
377 			   for with an artificially low tape size. */
378 			fetapes =
379 			(	  (double) tapesize	/* blocks */
380 				* TP_BSIZE	/* bytes/block */
381 				* (1.0/density)	/* 0.1" / byte " */
382 			  +
383 				  (double) tapesize	/* blocks */
384 				* (1.0/ntrec)	/* streaming-stops per block */
385 				* 15.48		/* 0.1" / streaming-stop " */
386 			) * (1.0 / tsize );	/* tape / 0.1" " */
387 		} else {
388 			/* Estimate number of tapes, for old fashioned 9-track
389 			   tape */
390 			int tenthsperirg = (density == 625) ? 3 : 7;
391 			fetapes =
392 			(	  (double) tapesize	/* blocks */
393 				* TP_BSIZE	/* bytes / block */
394 				* (1.0/density)	/* 0.1" / byte " */
395 			  +
396 				  (double) tapesize	/* blocks */
397 				* (1.0/ntrec)	/* IRG's / block */
398 				* tenthsperirg	/* 0.1" / IRG " */
399 			) * (1.0 / tsize );	/* tape / 0.1" " */
400 		}
401 		etapes = fetapes;		/* truncating assignment */
402 		etapes++;
403 		/* count the dumped inodes map on each additional tape */
404 		tapesize += (etapes - 1) *
405 			(howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
406 		tapesize += etapes + 10;	/* headers + 10 trailer blks */
407 		msg("estimated %ld tape blocks on %3.2f tape(s).\n",
408 		    tapesize, fetapes);
409 	}
410 
411 	/*
412 	 * Allocate tape buffer.
413 	 */
414 	if (!alloctape())
415 		quit(
416 	"can't allocate tape buffers - try a smaller blocking factor.\n");
417 
418 	startnewtape(1);
419 	(void)time((time_t *)&(tstart_writing));
420 	dumpmap(usedinomap, TS_CLRI, maxino - 1);
421 
422 	msg("dumping (Pass III) [directories]\n");
423 	dirty = 0;		/* XXX just to get gcc to shut up */
424 	for (map = dumpdirmap, ino = 1; ino < maxino; ino++) {
425 		if (((ino - 1) % NBBY) == 0)	/* map is offset by 1 */
426 			dirty = *map++;
427 		else
428 			dirty >>= 1;
429 		if ((dirty & 1) == 0)
430 			continue;
431 		/*
432 		 * Skip directory inodes deleted and maybe reallocated
433 		 */
434 		dp = getino(ino);
435 		if ((dp->di_mode & IFMT) != IFDIR)
436 			continue;
437 		(void)dumpino(dp, ino);
438 	}
439 
440 	msg("dumping (Pass IV) [regular files]\n");
441 	for (map = dumpinomap, ino = 1; ino < maxino; ino++) {
442 		int mode;
443 
444 		if (((ino - 1) % NBBY) == 0)	/* map is offset by 1 */
445 			dirty = *map++;
446 		else
447 			dirty >>= 1;
448 		if ((dirty & 1) == 0)
449 			continue;
450 		/*
451 		 * Skip inodes deleted and reallocated as directories.
452 		 */
453 		dp = getino(ino);
454 		mode = dp->di_mode & IFMT;
455 		if (mode == IFDIR)
456 			continue;
457 		(void)dumpino(dp, ino);
458 	}
459 
460 	(void)time((time_t *)&(tend_writing));
461 	spcl.c_type = TS_END;
462 	for (i = 0; i < ntrec; i++)
463 		writeheader(maxino - 1);
464 	if (pipeout)
465 		msg("DUMP: %ld tape blocks\n", spcl.c_tapea);
466 	else
467 		msg("DUMP: %ld tape blocks on %d volume%s\n",
468 		    spcl.c_tapea, spcl.c_volume,
469 		    (spcl.c_volume == 1) ? "" : "s");
470 
471 	/* report dump performance, avoid division through zero */
472 	if (tend_writing - tstart_writing == 0)
473 		msg("finished in less than a second\n");
474 	else
475 		msg("finished in %d seconds, throughput %d KBytes/sec\n",
476 		    tend_writing - tstart_writing,
477 		    spcl.c_tapea / (tend_writing - tstart_writing));
478 
479 	putdumptime();
480 	trewind();
481 	broadcast("DUMP IS DONE!\a\a\n");
482 	msg("DUMP IS DONE\n");
483 	Exit(X_FINOK);
484 	/* NOTREACHED */
485 }
486 
487 static void
488 usage()
489 {
490 	fprintf(stderr,
491 		"usage: dump [-0123456789ac"
492 #ifdef KERBEROS
493 		"k"
494 #endif
495 		"nu] [-B records] [-b blocksize] [-D dumpdates]\n"
496 		"            [-d density] [-f file ] [-h level] [-s feet] "
497 		"[-T date] filesystem\n"
498 		"       dump [-W | -w]\n");
499 	exit(X_STARTUP);
500 }
501 
502 /*
503  * Pick up a numeric argument.  It must be nonnegative and in the given
504  * range (except that a vmax of 0 means unlimited).
505  */
506 static long
507 numarg(meaning, vmin, vmax)
508 	char *meaning;
509 	long vmin, vmax;
510 {
511 	char *p;
512 	long val;
513 
514 	val = strtol(optarg, &p, 10);
515 	if (*p)
516 		errx(1, "illegal %s -- %s", meaning, optarg);
517 	if (val < vmin || (vmax && val > vmax))
518 		errx(1, "%s must be between %ld and %ld", meaning, vmin, vmax);
519 	return (val);
520 }
521 
522 void
523 sig(signo)
524 	int signo;
525 {
526 	switch(signo) {
527 	case SIGALRM:
528 	case SIGBUS:
529 	case SIGFPE:
530 	case SIGHUP:
531 	case SIGTERM:
532 	case SIGTRAP:
533 		if (pipeout)
534 			quit("Signal on pipe: cannot recover\n");
535 		msg("Rewriting attempted as response to unknown signal.\n");
536 		(void)fflush(stderr);
537 		(void)fflush(stdout);
538 		close_rewind();
539 		exit(X_REWRITE);
540 		/* NOTREACHED */
541 	case SIGSEGV:
542 		msg("SIGSEGV: ABORTING!\n");
543 		(void)signal(SIGSEGV, SIG_DFL);
544 		(void)kill(0, SIGSEGV);
545 		/* NOTREACHED */
546 	}
547 }
548 
549 char *
550 rawname(cp)
551 	char *cp;
552 {
553 	static char rawbuf[MAXPATHLEN];
554 	char *dp;
555 	struct stat sb;
556 
557 	if (stat(cp, &sb) == 0) {
558 		/*
559 		 * If the name already refers to a raw device, return
560 		 * it immediately without tampering.
561 		 */
562 		if ((sb.st_mode & S_IFMT) == S_IFCHR)
563 			return (cp);
564 	}
565 
566 	dp = strrchr(cp, '/');
567 
568 	if (dp == NULL)
569 		return (NULL);
570 	*dp = '\0';
571 	(void)strncpy(rawbuf, cp, MAXPATHLEN - 1);
572 	rawbuf[MAXPATHLEN-1] = '\0';
573 	*dp = '/';
574 	(void)strncat(rawbuf, "/r", MAXPATHLEN - 1 - strlen(rawbuf));
575 	(void)strncat(rawbuf, dp + 1, MAXPATHLEN - 1 - strlen(rawbuf));
576 	return (rawbuf);
577 }
578 
579 /*
580  * obsolete --
581  *	Change set of key letters and ordered arguments into something
582  *	getopt(3) will like.
583  */
584 static void
585 obsolete(argcp, argvp)
586 	int *argcp;
587 	char **argvp[];
588 {
589 	int argc, flags;
590 	char *ap, **argv, *flagsp, **nargv, *p;
591 
592 	/* Setup. */
593 	argv = *argvp;
594 	argc = *argcp;
595 
596 	/* Return if no arguments or first argument has leading dash. */
597 	ap = argv[1];
598 	if (argc == 1 || *ap == '-')
599 		return;
600 
601 	/* Allocate space for new arguments. */
602 	if ((*argvp = nargv = malloc((argc + 1) * sizeof(char *))) == NULL ||
603 	    (p = flagsp = malloc(strlen(ap) + 2)) == NULL)
604 		err(1, NULL);
605 
606 	*nargv++ = *argv;
607 	argv += 2;
608 
609 	for (flags = 0; *ap; ++ap) {
610 		switch (*ap) {
611 		case 'B':
612 		case 'b':
613 		case 'd':
614 		case 'f':
615 		case 'D':
616 		case 'h':
617 		case 's':
618 		case 'T':
619 			if (*argv == NULL) {
620 				warnx("option requires an argument -- %c", *ap);
621 				usage();
622 			}
623 			if ((nargv[0] = malloc(strlen(*argv) + 2 + 1)) == NULL)
624 				err(1, NULL);
625 			nargv[0][0] = '-';
626 			nargv[0][1] = *ap;
627 			(void)strcpy(&nargv[0][2], *argv);
628 			++argv;
629 			++nargv;
630 			break;
631 		default:
632 			if (!flags) {
633 				*p++ = '-';
634 				flags = 1;
635 			}
636 			*p++ = *ap;
637 			break;
638 		}
639 	}
640 
641 	/* Terminate flags. */
642 	if (flags) {
643 		*p = '\0';
644 		*nargv++ = flagsp;
645 	}
646 
647 	/* Copy remaining arguments. */
648 	while ((*nargv++ = *argv++));
649 
650 	/* Update argument count. */
651 	*argcp = nargv - *argvp - 1;
652 }
653