1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27/*	  All Rights Reserved	*/
28
29/*
30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 * The Regents of the University of California
32 * All Rights Reserved
33 *
34 * University Acknowledgment- Portions of this document are derived from
35 * software developed by the University of California, Berkeley, and its
36 * contributors.
37 */
38
39#include <sys/param.h>
40#include <signal.h>
41#include <sys/types.h>
42#include <sys/sysmacros.h>
43#include <sys/vnode.h>
44#include <sys/fs/ufs_fsdir.h>
45#include <sys/fs/ufs_inode.h>
46#include <sys/fs/ufs_fs.h>
47#include <sys/stat.h>
48#include <sys/statvfs.h>
49#include <fcntl.h>
50#include <stdio.h>
51#include <unistd.h>
52#include <stdlib.h>
53#include <errno.h>
54#include <signal.h>
55#include <stdarg.h>
56#include <sys/errno.h>
57#include <sys/utsname.h>
58#include <sys/ipc.h>
59#include <sys/sem.h>
60#include <sys/shm.h>
61#include <archives.h>
62#include "volcopy.h"
63
64#include <locale.h>
65
66/*
67 * main I/O information structure, contains information for the
68 * source and destination files.
69 */
70
71struct file_info {
72	char	*f_dev_p,	/* name of device */
73		*f_vol_p;	/* volume name */
74	int	f_bsize,	/* size to buffer I/O to */
75		f_des,		/* file descriptor */
76		f_dev;		/* device type (generic I/O library) */
77} In, Out;
78
79
80int	Sem_id[BUFCNT],	/* semaphore ids for controlling shared memory */
81	Shm_id[BUFCNT],	/* shared memory identifier */
82	*Cnts[BUFCNT];	/* an array of byte counts for shared memory */
83
84char	Empty[BLKSIZ],	/* empty memory used to clear sections of memory */
85	*Buf[BUFCNT];	/* buffer pointers (possibly to shared memory) */
86
87struct sembuf	Sem_buf,	/* semaphore operation buffer */
88		Rstsem_buf;	/* semaphore reset operation buffer */
89
90typedef union {
91	char		dummy[SBSIZE];
92	struct fs	sblk;
93
94} sb_un;
95
96sb_un	isup, osup, tsup;
97
98#define	Isup isup.sblk
99#define	Osup osup.sblk
100
101struct fs *Sptr = (struct fs *)&tsup.sblk;	/* super-block pointer */
102
103char    *Ifname, *Ifpack, *Ofname, *Ofpack;
104struct volcopy_label	V_labl;
105
106char	From_vol[VVOLLEN + 1],
107	To_vol[VVOLLEN + 1],
108	*Fsys_p;
109
110static	char	*nolabel = "";  /* used when there is no room for label */
111
112int	Blk_cnt = 1,	/* Do I/O in (Blk_cnt * BLKSIZ) byte blocks */
113	Blocks = 0,	/* Number of blocks transferred */
114	Bpi = 0,
115	Bufcnt,
116	Bufflg = 0,
117	Bufsz = BLKSIZ,
118	Disk_cnt = 1,	/* Disk I/O (Disk_cnt * Blk_cnt * BLKSIZ) byte blocks */
119	Drive_typ = 0,	/* Flag for special tape drive types */
120	Eomflg = 0,
121	Ipc = 0,
122	Itape,
123	M3b15 = 0,	/* Machine types, set to 1 for the machine */
124	M3b2 = 0,	/* the command is executing on */
125	Otape,
126	Pid = -1,
127	R_blks = 0,	/* Number of blocks per tape reel */
128	R_cur = 1,	/* Current tape reel being processed */
129	R_len = 0,	/* Length in feet of tape reels */
130	R_num = 0,	/* Number of tape reels to be processed */
131	Shell_esc = 1,	/* Allow shell after delete -nosh (3b15) can disable */
132	Yesflg = 0;
133
134void (*singal())();
135long	Fs,
136	Fstype;
137
138time_t	Tvec;
139
140FILE	*Devtty;
141
142static void	getinfs(),
143		getoutfs();
144
145static char	*getfslabel(struct fs *);
146static char	*getvolabel(struct fs *);
147static void	prompt(int, const char *, ...);
148static void	perr(int, const char *, ...);
149static void	mklabel(void);
150static void	get_mach_type(void);
151static void	mem_setup(void);
152static void	rprt(void);
153static void	chgreel(struct file_info *, int);
154static void	parent_copy(void);
155static void	copy(void);
156static void	flush_bufs(int);
157static void	cleanup(void);
158
159#ifdef LOG
160static int	fslog(void);
161#endif	/* LOG */
162
163/*
164 * g_init(), g_read(), g_write() originally came from libgenIO,
165 * a totally obsolete device interface library, now deleted.
166 * volcopy should be deleted too, since it doesn't work.
167 */
168
169#define	G_TM_TAPE	1	/* Tapemaster controller    */
170#define	G_XY_DISK	3	/* xy disks		*/
171#define	G_SD_DISK	7	/* scsi sd disk		*/
172#define	G_XT_TAPE	8	/* xt tapes		*/
173#define	G_SF_FLOPPY	9	/* sf floppy		*/
174#define	G_XD_DISK	10	/* xd disks		*/
175#define	G_ST_TAPE	11	/* scsi tape		*/
176#define	G_NS		12	/* noswap pseudo-dev	*/
177#define	G_RAM		13	/* ram pseudo-dev	*/
178#define	G_FT		14	/* tftp			*/
179#define	G_HD		15	/* 386 network disk	*/
180#define	G_FD		16	/* 386 AT disk		*/
181#define	G_FILE		28	/* file, not a device	*/
182#define	G_NO_DEV	29	/* device does not require special treatment */
183#define	G_DEV_MAX	30	/* last valid device type */
184
185/*
186 * g_init: Determine the device being accessed, set the buffer size,
187 * and perform any device specific initialization. Since at this point
188 * Sun has no system call to read the configuration, the major numbers
189 * are assumed to be static and types are figured out as such. However,
190 * as a rough estimate, the buffer size for all types is set to 512
191 * as a default.
192 */
193static int
194g_init(int *devtype, int *fdes)
195{
196	major_t maj;
197	int bufsize;
198	struct stat64 st_buf;
199	struct statvfs64 stfs_buf;
200
201	*devtype = G_NO_DEV;
202	if (fstat64(*fdes, &st_buf) == -1)
203		return (-1);
204	if (!S_ISCHR(st_buf.st_mode) && !S_ISBLK(st_buf.st_mode)) {
205		if (S_ISFIFO(st_buf.st_mode))
206			bufsize = 512;
207		else {
208			/* find block size for this file system */
209			*devtype = G_FILE;
210			if (fstatvfs64(*fdes, &stfs_buf) < 0) {
211				bufsize = -1;
212				errno = ENODEV;
213			} else {
214				bufsize = stfs_buf.f_bsize;
215			}
216		}
217		return (bufsize);
218	}
219
220	return (512);
221}
222
223/*
224 * g_read: Read nbytes of data from fdes (of type devtype) and place
225 * data in location pointed to by buf.  In case of end of medium,
226 * translate (where necessary) device specific EOM indications into
227 * the generic EOM indication of rv = -1, errno = ENOSPC.
228 */
229/* ARGSUSED */
230static ssize_t
231g_read(int devtype, int fdes, void *buf, size_t nbytes)
232{
233	ssize_t rv;
234
235	rv = read(fdes, buf, nbytes);
236
237	/* st devices return 0 when no space left */
238	if ((rv == 0 && errno == 0) || (rv == -1 && errno == EIO)) {
239		errno = ENOSPC;
240		rv = -1;
241	}
242
243	return (rv);
244}
245
246/*
247 * g_write: Write nbytes of data to fdes (of type devtype) from
248 * the location pointed to by buf.  In case of end of medium,
249 * translate (where necessary) device specific EOM indications into
250 * the generic EOM indication of rv = -1, errno = ENOSPC.
251 */
252/* ARGSUSED */
253static ssize_t
254g_write(int devtype, int fdes, void *buf, size_t nbytes)
255{
256	ssize_t rv;
257
258	rv = write(fdes, buf, nbytes);
259
260	/* st devices return 0 when no more space left */
261	if ((rv == 0 && errno == 0) || (rv == -1 && errno == EIO)) {
262		errno = ENOSPC;
263		rv = -1;
264	}
265
266	return (rv);
267}
268
269/*
270 * filesystem copy with propagation of volume ID and filesystem name:
271 *
272 * volcopy [-options]  filesystem /dev/from From_vol /dev/to To_vol
273 *
274 * options are:
275 *	-feet - length of tape
276 *	-bpi  - recording density
277 *	-reel - reel number (if not starting from beginning)
278 *	-buf  - use double buffered i/o (if dens >= 1600 bpi)
279 *	-block - Set the transfer block size to NUM physical blocks (512
280 *	bytes on 3B2 and 3B15).  Note that an arbitrary block size might
281 *	or might not work on a given system.  Also, the block size
282 *	read from the header of an input tape silently overrides this.
283 *	-nosh - Don't offer the user a shell after hitting break or delete.
284 *	-r - Read NUM transfer blocks from the disk at once and write it
285 *	to the output device one block at a time.  Intended only to
286 *	boost the 3B15 EDFC disk to tape performance.  Disabled on 3B2.
287 *	-a    - ask "y or n" instead of "DEL if wrong"
288 *	-s    - inverse of -a, from/to devices are printed followed by `?'.
289 *		User has 10 seconds to DEL if mistaken!
290 *	-y    - assume "yes" response to all questions
291 *
292 * Examples:
293 *
294 * volcopy root /dev/rdsk/0s2 pk5 /dev/rdsk/1s2 pk12
295 *
296 * volcopy u3 /dev/rdsk/1s5 pk1 /dev/rmt/0m tp123
297 *
298 * volcopy u5 /dev/rmt/0m -  /dev/rdsk/1s5 -
299 */
300
301int
302main(int argc, char *argv[])
303{
304	char c;
305	int lfdes, altflg = 0, result, verify;
306	long dist;
307	char *align();
308	void sigalrm(), sigint();
309	struct stat stbuf;
310	int cnt;
311
312	(void) setlocale(LC_ALL, "");
313#if !defined(TEXT_DOMAIN)
314#define	TEXT_DOMAIN "SYS_TEST"
315#endif
316	(void) textdomain(TEXT_DOMAIN);
317
318	(void) get_mach_type();
319	(void) signal(SIGINT, sigint);
320	(void) signal(SIGALRM, sigalrm);
321	In.f_bsize = Out.f_bsize = BLKSIZ;
322	while (argc > 1 && argv[1][0] == '-') {
323		if (EQ(argv[1], "-a", 2)) {
324			altflg |= MINUSA;
325		} else if (EQ(argv[1], "-e", 2)) {
326			Eomflg = 1;
327		} else if (EQ(argv[1], "-s", 2)) {
328			altflg |= MINUSS;
329		} else if (EQ(argv[1], "-y", 2)) {
330			Yesflg++;
331		} else if (EQ(argv[1], "-buf", 4)) {
332			Bufflg++;
333		} else if (EQ(argv[1], "-bpi", 4)) {
334			if ((c = argv[1][4]) >= '0' && c <= '9')
335				Bpi = getbpi(&argv[1][4]);
336			else {
337				++argv;
338				--argc;
339				Bpi = getbpi(&argv[1][0]);
340			}
341		} else if (EQ(argv[1], "-feet", 5)) {
342			if ((c = argv[1][5]) >= '0' && c <= '9')
343				R_len = atoi(&argv[1][5]);
344			else {
345				++argv;
346				--argc;
347				R_len = atoi(&argv[1][0]);
348			}
349		} else if (EQ(argv[1], "-reel", 5)) {
350			if ((c = argv[1][5]) >= '0' && c <= '9')
351				R_cur = atoi(&argv[1][5]);
352			else {
353				++argv;
354				--argc;
355				R_cur = atoi(&argv[1][0]);
356			}
357		} else if (EQ(argv[1], "-r", 2)) { /* 3b15 only */
358			if ((c = argv[1][2]) >= '0' && c <= '9')
359				Disk_cnt = atoi(&argv[1][2]);
360			else {
361				++argv;
362				--argc;
363				Disk_cnt = atoi(&argv[1][0]);
364			}
365			if (Disk_cnt == 0)
366		perr(1, "volcopy: Need a non-zero value for the -r option\n");
367		} else if (EQ(argv[1], "-block", 6)) { /* 3b15 only */
368			if ((c = argv[1][6]) >= '0' && c <= '9')
369				Blk_cnt = atoi(&argv[1][6]);
370			else {
371				++argv;
372				--argc;
373				Blk_cnt = atoi(&argv[1][0]);
374			}
375			if (Blk_cnt == 0)
376	perr(1, "volcopy: Need a non-zero value for the -block option\n");
377		} else if (EQ(argv[1], "-nosh", 5)) { /* 3b15 only */
378			Shell_esc = 0;
379		} else
380			perr(1, "<%s> invalid option\n", argv[1]);
381		++argv;
382		--argc;
383	} /* argv[1][0] == '-' */
384
385	Devtty = fopen("/dev/tty", "r");
386	if ((Devtty == NULL) && !isatty(0))
387		Devtty = stdin;
388	time(&Tvec);
389
390	if (Eomflg && R_len)
391		perr(9, "volcopy: -e and -feet are mutually exclusive\n");
392	if ((altflg & MINUSA) && (altflg & MINUSS))
393		perr(9, "volcopy: -a and -s are mutually exclusive\n");
394	if (argc != 6) /* if mandatory fields not present */
395		perr(9, "ufs usage: volcopy [-F ufs] [generic options] \
396fsname /devfrom volfrom /devto volto\n");
397	if (!(altflg & MINUSA)) /* -a was not specified, use default (-s) */
398		altflg |= MINUSS;
399
400	In.f_dev_p = argv[DEV_IN];
401	Out.f_dev_p = argv[DEV_OUT];
402	strncpy(To_vol, argv[VOL_OUT], VVOLLEN);
403	To_vol[VVOLLEN] = '\0';
404	Out.f_vol_p = &To_vol[0];
405	strncpy(From_vol, argv[VOL_IN], VVOLLEN);
406	From_vol[VVOLLEN] = '\0';
407	In.f_vol_p = &From_vol[0];
408	Fsys_p = argv[FIL_SYS];
409
410	if ((In.f_des = open(In.f_dev_p, O_RDONLY)) < 1)
411		perr(10, "%s: cannot open\n", In.f_dev_p);
412	if ((Out.f_des = open(Out.f_dev_p, O_RDONLY)) < 1)
413		perr(10, "%s: cannot open\n", Out.f_dev_p);
414
415	if (fstat(In.f_des, &stbuf) < 0 || (stbuf.st_mode & S_IFMT) != S_IFCHR)
416		perr(10, "From device not character-special\n");
417	if (fstat(Out.f_des, &stbuf) < 0 || (stbuf.st_mode & S_IFMT) != S_IFCHR)
418		perr(10, "To device not character-special\n");
419
420	if ((Itape = tapeck(&In, INPUT)) == 1)
421		R_blks = V_labl.v_reelblks;
422	Otape = tapeck(&Out, OUTPUT);
423	if (Otape && Itape)
424		perr(10, "Use dd(1) command to copy tapes\n");
425	(void) mem_setup();
426	if (Bufflg && !Ipc)
427		perr(1, "The -buf option requires ipc\n");
428	if (!Itape && !Otape)
429		R_cur = 1;
430	if (R_cur == 1 || !Itape) {
431		/* read in superblock */
432		verify = 0;
433		(void) getinfs(In.f_dev, In.f_des, Sptr);
434
435		if ((Sptr->fs_magic != FS_MAGIC) &&
436		    (Sptr->fs_magic != MTB_UFS_MAGIC))
437			perr(10, "File System type unknown--get help\n");
438
439		if (Sptr->fs_magic == FS_MAGIC &&
440		    (Sptr->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
441		    Sptr->fs_version != UFS_VERSION_MIN))
442			perr(10, "Unrecognized version of UFS--get help\n");
443
444		if (Sptr->fs_magic == MTB_UFS_MAGIC &&
445		    (Sptr->fs_version > MTB_UFS_VERSION_1 ||
446		    Sptr->fs_version < MTB_UFS_VERSION_MIN))
447			perr(10, "Unrecognized version of UFS--get help\n");
448
449		(void) memcpy(&Isup, Sptr, Sptr->fs_sbsize);
450		Ifname = getfslabel(&Isup);
451		Ifpack = getvolabel(&Isup);
452		Fs = Sptr->fs_size * Sptr->fs_nspf;
453	}  /* R_cur == 1 || !Itape */
454
455	/* read in superblock */
456	verify = !Otape || (altflg & MINUSS);
457	(void) getoutfs(Out.f_dev, Out.f_des, Sptr, verify);
458
459	if ((Sptr->fs_magic == FS_MAGIC) || (Sptr->fs_magic == MTB_UFS_MAGIC)) {
460		(void) memcpy(&Osup, Sptr, Sptr->fs_sbsize);
461		Ofname = getfslabel(&Osup);
462		Ofpack = getvolabel(&Osup);
463	} else  {
464		int i;
465
466		/* out vol does not contain a ufs file system */
467		/* stuff let over from Isup */
468		(void) memcpy(&Osup, &Isup, Isup.fs_sbsize);
469		Ofname = getfslabel(&Osup);
470		Ofpack = getvolabel(&Osup);
471		/* wipe out the fs name and pack name for warning purposes */
472		for (i = 0; i < 6; i++) Ofname[i] = ' ';
473		for (i = 0; i < 6; i++) Ofpack[i] = ' ';
474	}
475
476	if (Itape) {
477		if (R_cur != 1) {
478			(void) printf(gettext(
479				"\nvolcopy: IF REEL 1 HAS NOT BEEN RESTORED,"));
480			(void) printf(gettext(
481				" STOP NOW AND START OVER ***\07\n"));
482			if (!ask(" Continue? ")) {
483				cleanup();
484				exit(31+9);
485			}
486			strncpy(Ifname, Fsys_p, 6);
487			strncpy(Ifpack, In.f_vol_p, 6);
488		}
489		if (V_labl.v_reel != R_cur || V_labl.v_reels != R_num)
490	prompt(1, "Tape disagrees: Reel %d of %d : looking for %d of %d\n",
491				V_labl.v_reel, V_labl.v_reels, R_cur, R_num);
492	} else if (Otape) {
493		strncpy(V_labl.v_volume, Out.f_vol_p, 6);
494		strncpy(Ofpack, Out.f_vol_p, 6);
495		strncpy(Ofname, Fsys_p, 6);
496		if (!Eomflg) {
497			R_num = Fs / R_blks + ((Fs % R_blks) ? 1 : 0);
498			(void) printf(gettext(
499				"You will need %d reels.\n"), R_num);
500			(void) printf(gettext(
501		"(\tThe same size and density is expected for all reels)\n"));
502		}
503	}
504	if (NOT_EQ(Fsys_p, Ifname, 6)) {
505		verify = !Otape || (altflg & MINUSS);
506		prompt(verify,
507			"arg. (%.6s) doesn't agree with from fs. (%.6s)\n",
508			Fsys_p, Ifname);
509	}
510	if (NOT_EQ(In.f_vol_p, "-", 6) && NOT_EQ(In.f_vol_p, Ifpack, 6)) {
511		verify = !Otape || (altflg & MINUSS);
512	prompt(verify, "arg. (%.6s) doesn't agree with from vol.(%.6s)\n",
513			In.f_vol_p, Ifpack);
514	}
515
516	if (*In.f_vol_p == '-')
517		In.f_vol_p = Ifpack;
518	if (*Out.f_vol_p == '-')
519		Out.f_vol_p = Ofpack;
520
521	if (R_cur == 1 && (Osup.fs_time + _2_DAYS) > Isup.fs_time) {
522		time_t t;
523
524		verify = altflg & MINUSS;
525		t = (time_t)Osup.fs_time;
526		prompt(verify, "%s less than 48 hours older than %s\n"
527		    "To filesystem dated:  %s",
528		    Out.f_dev_p, In.f_dev_p, ctime(&t));
529	}
530	if (NOT_EQ(Out.f_vol_p, Ofpack, 6)) {
531		prompt(1, "arg.(%.6s) doesn't agree with to vol.(%.6s)\n",
532			Out.f_vol_p, Ofpack);
533		strncpy(Ofpack, Out.f_vol_p, 6);
534	}
535	if (Isup.fs_size > Osup.fs_size && !Otape)
536		prompt(1, "from fs larger than to fs\n");
537	if (!Otape && NOT_EQ(Ifname, Ofname, 6)) {
538		verify = altflg & MINUSS;
539	prompt(verify, "warning! from fs(%.6s) differs from to fs(%.6s)\n",
540			Ifname, Ofname);
541	}
542
543	(void) printf(gettext("From: %s, to: %s? "), In.f_dev_p, Out.f_dev_p);
544	if (!(altflg & MINUSA)) {
545		(void) printf(gettext("(DEL if wrong)\n"));
546		sleep(10);
547	} else if (!ask("(y or n) "))
548		perr(10, "\nvolcopy: STOP\n");
549	close(In.f_des);
550	close(Out.f_des);
551	sync();
552	In.f_des = open(In.f_dev_p, O_RDONLY);
553	Out.f_des = open(Out.f_dev_p, O_WRONLY);
554	errno = 0;
555	if (g_init(&In.f_dev, &In.f_des) < 0 ||
556	    g_init(&Out.f_dev, &Out.f_des) < 0)
557		perr(1, "volcopy: Error %d during initialization\n", errno);
558	if (Itape) {
559		errno = 0;
560		if (g_read(In.f_dev, In.f_des, &V_labl, sizeof (V_labl)) <
561		    sizeof (V_labl))
562			perr(10, "Error while reading label\n");
563	} else if (Otape) {
564		V_labl.v_reels = R_num;
565		V_labl.v_reel = R_cur;
566		V_labl.v_time = Tvec;
567		V_labl.v_reelblks = R_blks;
568		V_labl.v_blksize = BLKSIZ * Blk_cnt;
569		V_labl.v_nblocks = Blk_cnt;
570		V_labl.v_offset = 0L;
571		V_labl.v_type = T_TYPE;
572		errno = 0;
573		if (g_write(Out.f_dev, Out.f_des, &V_labl, sizeof (V_labl)) <
574		    sizeof (V_labl))
575			perr(10, "Error while writing label\n");
576	}
577	if (R_cur > 1) {
578		if (!Eomflg) {
579			Fs = (R_cur - 1) * actual_blocks();
580			lfdes = Otape ? In.f_des : Out.f_des;
581			dist = (long)(Fs * BLKSIZ);
582		} else { /* Eomflg */
583			if (Otape)
584		perr(1, "Cannot use -reel with -e when copying to tape\n");
585			lfdes = Out.f_des;
586			dist = (long)(V_labl.v_offset * BLKSIZ);
587			Fs = V_labl.v_offset;
588		}
589		if (lseek(lfdes, dist, 0) < 0)
590			perr(1, "Cannot lseek()\n");
591		Sptr = Otape ? &Isup : &Osup;
592		if ((Sptr -> fs_magic != FS_MAGIC) &&
593		    (Sptr -> fs_magic != MTB_UFS_MAGIC))
594			perr(10, "File System type unknown--get help!\n");
595
596		if (Sptr->fs_magic == FS_MAGIC &&
597		    (Sptr->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
598		    Sptr->fs_version != UFS_VERSION_MIN))
599			perr(10, "Unrecognized version of UFS--get help\n");
600
601		if (Sptr->fs_magic == MTB_UFS_MAGIC &&
602		    (Sptr->fs_version > MTB_UFS_VERSION_1 ||
603		    Sptr->fs_version < MTB_UFS_VERSION_MIN))
604			perr(10, "Unrecognized version of UFS--get help\n");
605
606		Fs = (Sptr->fs_size * Sptr->fs_nspf) - Fs;
607	}
608	if (Itape || Otape)
609		rprt();
610
611	if (Ipc) {
612		parent_copy();
613		(void) cleanup();
614	} else
615		copy();
616	(void) printf(gettext("  END: %ld blocks.\n"), Blocks);
617
618#ifdef LOG
619	fslog();
620#endif
621	if (Blocks)
622		return (0);
623	return (31+1);		/* failed.. 0 blocks */
624}
625
626/*
627 * sigalrm: catch alarm signals.
628 */
629
630void
631sigalrm()
632{
633	void (*signal())();
634
635	(void) signal(SIGALRM, sigalrm);
636}
637
638/*
639 * sigsys: catch illegal system calls to determine if IPC is available.
640 */
641
642void
643sigsys()
644{
645
646	Ipc = 0;
647}
648
649/*
650 * sigint: catch interrupts and prompt user for shell or to quit.
651 */
652
653void
654sigint()
655{
656	void (*signal())();
657	extern char **environ;
658	int tmpflg, i = 0, ps1 = -1, ps2 = -1;
659
660	tmpflg = Yesflg; /* override yesflag for duration of interrupt */
661	Yesflg = 0;
662	if (Shell_esc && ask("Want Shell?   ")) {
663		if (!fork()) {
664			/* both PS1 and PS2 must be exported */
665			while (environ[i]) {
666				if (EQ(environ[i], "PS1", 3))
667					ps1 = i;
668				if (EQ(environ[i], "PS2", 3))
669					ps2 = i;
670				i++;
671			}
672			if (ps1 >= 0 && ps2 >= 0)
673				environ[ps1] = environ[ps2];
674			(void) signal(SIGINT, SIG_DFL);
675			execl("/usr/bin/sh", "/usr/bin/sh", 0);
676		} else { /* parent */
677			(void) signal(SIGINT, SIG_IGN);
678			wait((int *)0);
679		}
680	} else if (ask("Want to quit?    ")) {
681		if (Pid > 0)
682			kill(Pid, 9);
683		(void) cleanup(); /* ipc */
684		exit(31+2);
685	}
686	(void) signal(SIGINT, sigint);
687	Yesflg = tmpflg; /* reset Yesflg */
688}
689
690/*
691 * actual_blocks: Calculate the actual number of blocks written to
692 * the tape (will differ from V_labl.v_reelblks if v_reelblks is not
693 * an even multiple of the blocking factor Blk_cnt).
694 */
695
696int
697actual_blocks()
698{
699
700	if (R_blks % Blk_cnt)
701		return (((R_blks / Blk_cnt) + 1) * Blk_cnt);
702	else
703		return (R_blks);
704}
705
706/*
707 * get_mach_type: Determine what machine this is executing on.
708 */
709
710static void
711get_mach_type(void)
712{
713	struct utsname utsinfo;
714
715	errno = 0;
716	if (uname(&utsinfo) < 0)
717		perr(1, "Unable to determine machine type\n");
718	if (strcmp(utsinfo.machine, "3B2") == 0)
719		M3b2 = 1;
720	else if (strcmp(utsinfo.machine, "3B15") == 0)
721		M3b15 = 1;
722}
723
724/*
725 * mem_setup: Determine memory needs and check for IPC.  If IPC is available,
726 * used shared memory and semaphores to increase performance.  If no IPC,
727 * get normal memory and only use one process.
728 */
729
730static void
731mem_setup(void)
732{
733	void (*signal())();
734	int cnt, num, size;
735	char *align();
736
737	union semun {
738		int val;
739		struct semid_ds *buf;
740		ushort_t *array;
741	} sem_arg;
742
743	if (Blk_cnt == 1) {
744		switch (Drive_typ) {
745		case A_DRIVE:
746			Blk_cnt = 32;
747			break;
748		case C_DRIVE:
749			Blk_cnt = 10;
750			break;
751		case K_DRIVE:
752			Blk_cnt = 4;
753			break;
754		case T_DRIVE:
755			if (Bpi == 6250)
756				Blk_cnt = 50;
757			else
758				Blk_cnt = 10;
759			break;
760		default:
761			if (M3b15) {
762				if (Itape || Otape)
763					Blk_cnt = 16;
764			} else {
765				if (Otape || Itape) {
766					if (Bpi == 6250)
767						Blk_cnt = 50;
768					else
769						Blk_cnt = 10;
770				}
771			}
772			break;
773		} /* Drive_typ */
774	} /* Blk_cnt == 1 */
775	if (Blk_cnt > 1) /* user overrode g_init */
776		In.f_bsize = Out.f_bsize = Blk_cnt * BLKSIZ;
777	In.f_bsize = (!Itape) ? Disk_cnt * In.f_bsize : In.f_bsize;
778	Out.f_bsize = (!Otape) ? Disk_cnt * Out.f_bsize : Out.f_bsize;
779	Bufsz = find_lcm(In.f_bsize, Out.f_bsize);
780	num = _128K / (Bufsz + sizeof (int));
781	Bufsz *= num;
782	size = Bufsz + sizeof (int);
783	/* test to see if ipc is available, the shmat should fail with EINVAL */
784	(void) signal(SIGSYS, sigsys);
785	errno = 0;
786	if (Ipc) {
787		if ((int)shmat(0, (char *)NULL, 0) < 0 && errno != EINVAL)
788			Ipc = 0; /* something went wrong */
789	}
790	if (Ipc) { /* ipc is available */
791		Bufcnt = 2;
792		sem_arg.val = 0;
793		for (cnt = 0; cnt < BUFCNT; cnt++) {
794			errno = 0;
795			if ((Sem_id[cnt] = semget(IPC_PRIVATE, 1, 0)) < 0)
796				perr(1, "Error allocating semaphores: %d",
797				    errno);
798			if (semctl(Sem_id[cnt], 0, SETVAL, sem_arg) < 0)
799				perr(1, "Error setting semaphores: %d", errno);
800			if ((Shm_id[cnt] = shmget(IPC_PRIVATE, size, 0)) < 0)
801				perr(1, "Error allocating shared memory: %d",
802				    errno);
803			if ((Buf[cnt] = shmat(Shm_id[cnt], 0, 0)) == (void *)-1)
804				perr(1, "Error attaching shared memory: %d",
805				    errno);
806			if (shmctl(Shm_id[cnt], SHM_LOCK, 0) < 0)
807				perr(0, "Error locking in shared memory: %d",
808				    errno);
809			Cnts[cnt] = (int *)(Buf[cnt] + Bufsz);
810		}
811	} else { /* ipc is not available */
812		Bufcnt = 1;
813		if ((Buf[0] = align(size)) == (char *)NULL)
814			perr(1, "Out of memory\n");
815		Cnts[0] = (int *)(Buf[0] + Bufsz);
816		*Cnts[0] = 0;
817	}
818}
819
820/*
821 * prompt: Prompt the user for verification.
822 */
823
824static void
825prompt(int verify, const char *fmt, ...)
826{
827	va_list ap;
828
829	va_start(ap, fmt);
830	if (fmt != NULL)
831		(void) vfprintf(stdout, gettext(fmt), ap);
832	va_end(ap);
833	if (verify) {
834		(void) fprintf(stdout, gettext("Type 'y' to override:    "));
835		if (!ask("")) {
836			cleanup();
837			exit(31+9);
838		}
839	}
840}
841
842/*
843 * ask: Ask the user a question and get the answer.
844 */
845
846int
847ask(char *s)
848{
849	char ans[12];
850
851	(void) printf(gettext(s));
852	if (Yesflg) {
853		(void) printf(gettext("YES\n"));
854		return (1);
855	}
856	ans[0] = '\0';
857	fgets(ans, 10, Devtty);
858	for (;;) {
859		switch (ans[0]) {
860			case 'a':
861			case 'A':
862				if (Pid > 0) /* parent with a child */
863					kill(Pid, 9);
864				cleanup();
865				exit(31+1);
866			case 'y':
867			case 'Y':
868				return (1);
869			case 'n':
870			case 'N':
871				return (0);
872			default:
873				(void) printf(gettext("\n(y or n)?"));
874				fgets(ans, 10, Devtty);
875		}
876	}
877}
878
879/*
880 * align: Align a malloc'd memory section on a page boundry.
881 */
882
883char *
884align(int size)
885{
886	int pad;
887
888	if ((pad = ((int)malloc(0) & (PAGESIZE-1))) > 0) {
889		pad = PAGESIZE - pad;
890		if (malloc(pad) == (char *)NULL)
891			return ((char *)NULL);
892	}
893	return (malloc((unsigned)size));
894}
895
896/*
897 * child_copy:  Using IPC, this child process reads from shared memory
898 * and writes to the destination file system.
899 */
900
901int
902child_copy()
903{
904	int rv, cur_buf, left, have, tpcnt;
905	char *c_p;
906
907	(void) signal(SIGINT, SIG_IGN);
908	Sem_buf.sem_op = -1;
909	(void) close(In.f_des);
910	if (Otape && !Eomflg)
911		tpcnt = actual_blocks() * BLKSIZ;
912	cur_buf = 0;
913	for (;;) {
914		if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
915			perr(1, "semaphore operation error %d\n", errno);
916		left = *Cnts[cur_buf];
917		if (!left)
918			break;
919		c_p = Buf[cur_buf];
920		rv = 0;
921		while (left) {
922			have = (left < Out.f_bsize) ? left : Out.f_bsize;
923			if (!Eomflg && Otape) {
924				if (!tpcnt) {
925					(void) chgreel(&Out, OUTPUT);
926					tpcnt = actual_blocks() * BLKSIZ;
927				}
928				have = (tpcnt < have) ? tpcnt : have;
929			}
930			errno = 0;
931			if ((rv = g_write(Out.f_dev, Out.f_des, c_p, have)) <
932			    0) {
933				if (Eomflg && errno == ENOSPC) {
934					(void) chgreel(&Out, OUTPUT);
935					continue;
936				} else
937					perr(1, "I/O error %d on write\n",
938					    errno);
939			}
940			left -= rv;
941			c_p += rv;
942			V_labl.v_offset += rv;
943			if (!Eomflg && Otape)
944				tpcnt -= rv;
945		}
946		if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
947			perr(2, "semaphore operation error %d\n", errno);
948		cur_buf = (cur_buf + 1) % BUFCNT;
949	}
950	exit(0);
951}
952
953/*
954 * parent_copy:  Using shared memory, the parent process reads fromt the
955 * source file system and writes to shared memory.
956 */
957
958static void
959parent_copy(void)
960{
961	int rv, left, have, tpcnt, cur_buf;
962	char *c_p;
963	int eom = 0, xfer_cnt = Fs * BLKSIZ;
964
965	Sem_buf.sem_num = 0;
966	Sem_buf.sem_flg = 0;
967	if ((Pid = fork()) == 0)
968		child_copy(); /* child does not return */
969	(void) close(Out.f_des);
970	Rstsem_buf.sem_num = 0;
971	Rstsem_buf.sem_flg = 0;
972	Rstsem_buf.sem_op = 2;
973	Sem_buf.sem_op = 0;
974	cur_buf = 0;
975	if (Itape && !Eomflg)
976		tpcnt = actual_blocks() * BLKSIZ;
977	while (xfer_cnt) {
978		if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
979			perr(1, "Semaphore operation error %d\n", errno);
980		c_p = Buf[cur_buf];
981		left = Bufsz;
982		rv = 0;
983		while (left >= In.f_bsize && xfer_cnt) {
984			have = (xfer_cnt < In.f_bsize) ? xfer_cnt : In.f_bsize;
985			if (!Eomflg && Itape) {
986				if (!tpcnt) {
987					*Cnts[cur_buf] = Bufsz - left;
988					(void) flush_bufs(cur_buf);
989					(void) chgreel(&In, INPUT);
990					tpcnt = actual_blocks() * BLKSIZ;
991					cur_buf = (cur_buf == 0) ? 1 : 0;
992					eom = 1;
993					break;
994				}
995				have = (tpcnt < have) ? tpcnt : have;
996			}
997			errno = 0;
998			if ((rv = g_read(In.f_dev, In.f_des, c_p, have)) < 0) {
999				if (Eomflg && errno == ENOSPC) {
1000					*Cnts[cur_buf] = Bufsz - left;
1001					(void) flush_bufs(cur_buf);
1002					(void) chgreel(&In, INPUT);
1003					cur_buf = (cur_buf == 0) ? 1 : 0;
1004					eom = 1;
1005					break;
1006				} else
1007					perr(1, "I/O error %d on read\n",
1008					    errno);
1009			}
1010			left -= rv;
1011			c_p += rv;
1012			xfer_cnt -= rv;
1013			if (!Eomflg && Itape)
1014				tpcnt -= rv;
1015		}
1016		if (eom > 0) {
1017			eom = 0;
1018			if (Eomflg)
1019				xfer_cnt -= rv;
1020			else if (Itape)
1021				tpcnt -= rv;
1022			continue;
1023		}
1024		*Cnts[cur_buf] = Bufsz - left;
1025		Blocks += *Cnts[cur_buf];
1026		if (semop(Sem_id[cur_buf], &Rstsem_buf, 1) < 0)
1027			perr(2, "Semaphore operation error %d\n", errno);
1028		cur_buf = (cur_buf == 0) ? 1 : 0;
1029	}
1030	if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
1031		perr(3, "Semaphore operation error %d\n", errno);
1032	*Cnts[cur_buf] = 0;
1033	if (semop(Sem_id[cur_buf], &Rstsem_buf, 1) < 0)
1034		perr(4, "Semaphore operation error %d\n", errno);
1035	wait((int *)NULL);
1036	Blocks /= BLKSIZ;
1037}
1038
1039/*
1040 * copy:  Copy without shared memory.  The process reads from the source
1041 * filesystem and writes to the destination filesystem.
1042 */
1043
1044static void
1045copy(void)
1046{
1047	int rv, left, have, tpcnt = 1, xfer_cnt = Fs * BLKSIZ;
1048	char *c_p;
1049
1050	if ((Itape || Otape) && !Eomflg)
1051		tpcnt = actual_blocks() * BLKSIZ;
1052	while (xfer_cnt) {
1053		c_p = (char *)(Buf[0] + *Cnts[0]);
1054		left = Bufsz - *Cnts[0];
1055		rv = 0;
1056		while (left >= In.f_bsize && xfer_cnt) {
1057			have = (xfer_cnt < In.f_bsize) ? xfer_cnt : In.f_bsize;
1058			if (!Eomflg && Itape) {
1059				if (!tpcnt) {
1060					*Cnts[0] = Bufsz - left;
1061					(void) chgreel(&In, INPUT);
1062					tpcnt = actual_blocks() * BLKSIZ;
1063					break;
1064				}
1065				have = (tpcnt < have) ? tpcnt : have;
1066			}
1067			errno = 0;
1068			if ((rv = g_read(In.f_dev, In.f_des, c_p, have)) < 0) {
1069				if (Eomflg && errno == ENOSPC) {
1070					(void) chgreel(&In, INPUT);
1071					break;
1072				} else
1073					perr(1, "I/O error %d on read\n",
1074					    errno);
1075			}
1076			left -= rv;
1077			c_p += rv;
1078			xfer_cnt -= rv;
1079			if (!Eomflg && Itape)
1080				tpcnt -= rv;
1081		} /* left >= In.f_bsize && xfer_cnt */
1082		*Cnts[0] = Bufsz - left;
1083		Blocks += *Cnts[0];
1084		c_p = Buf[0];
1085		left = *Cnts[0];
1086		rv = 0;
1087		while (left >= Out.f_bsize || (left > 0 && !xfer_cnt)) {
1088			have = (left < Out.f_bsize) ? left : Out.f_bsize;
1089			if (!Eomflg && Otape) {
1090				if (!tpcnt) {
1091					(void) chgreel(&Out, OUTPUT);
1092					tpcnt = actual_blocks() * BLKSIZ;
1093				}
1094				have = (tpcnt < have) ? tpcnt : have;
1095			}
1096			errno = 0;
1097			if ((rv = g_write(Out.f_dev, Out.f_des, c_p, have)) <
1098			    0) {
1099				if (Eomflg && errno == ENOSPC) {
1100					(void) chgreel(&Out, OUTPUT);
1101					continue;
1102				} else
1103					perr(1, "I/O error %d on write\n",
1104					    errno);
1105			}
1106			left -= rv;
1107			c_p += rv;
1108			V_labl.v_offset += rv;
1109			if (!Eomflg && Otape)
1110				tpcnt -= rv;
1111		} /* left >= Out.f_bsize */
1112		if (left) {
1113			(void) memcpy(Buf[0], c_p, left);
1114			Blocks -= left;
1115		}
1116		*Cnts[0] = left;
1117	} /* xfer_cnt */
1118	Blocks /= BLKSIZ;
1119}
1120
1121/*
1122 * flush_bufs:  Permit child to read the remaining data from the
1123 * buffer before prompting user for end-of-media.
1124 */
1125
1126static void
1127flush_bufs(int buffer)
1128{
1129
1130	Blocks += *Cnts[buffer];
1131	if (semop(Sem_id[buffer], &Rstsem_buf, 1) < 0)
1132		perr(5, "Semaphore operation error %d\n", errno);
1133	if (semop(Sem_id[buffer], &Sem_buf, 1) < 0)
1134		perr(6, "Semaphore operation error %d\n", errno);
1135}
1136
1137/*
1138 * cleanup:  Clean up shared memory and semaphore resources.
1139 */
1140
1141static void
1142cleanup(void)
1143{
1144	int cnt;
1145
1146	if (Ipc) {
1147		for (cnt = 0; cnt < BUFCNT; cnt++) {
1148			(void) semctl(Sem_id[cnt], IPC_RMID, 0);
1149			(void) shmctl(Shm_id[cnt], IPC_RMID, 0);
1150		}
1151	}
1152}
1153
1154/*
1155 * find_lcm: Find the lowest common multiple of two numbers.  This is used
1156 * to determine the buffer size that should be malloc(3)'d such that the
1157 * input and output data blocks can both fit evenly into the buffer.
1158 */
1159
1160int
1161find_lcm(int sz1, int sz2)
1162{
1163	int inc, lcm, small;
1164
1165	if (sz1 < sz2) {
1166		lcm = inc = sz2;
1167		small = sz1;
1168	} else { /* sz1 >= sz2 */
1169		lcm = inc = sz1;
1170		small = sz2;
1171	}
1172	while (lcm % small != 0)
1173		lcm += inc;
1174	return (lcm);
1175}
1176
1177/*
1178 * Determine bpi information from drive names.
1179 */
1180
1181int
1182getbpi(char *inp)
1183{
1184
1185/*
1186 * Kludge to recognize Accellerated Tape Controller usage from
1187 * letter 'a' or 'A' following density given by user.
1188 *
1189 * Kludge to recognize 3B15 Compatibility Mode from
1190 * letter 'c' or 'C' following density given by user.
1191 */
1192	if (M3b15) {
1193		if (inp[4] == 'a' || inp[4] == 'A') {
1194			Drive_typ = A_DRIVE;
1195			inp[4] = '\0';
1196		}
1197		if (inp[4] == 'c' || inp[4] == 'C') {
1198			Drive_typ = C_DRIVE;
1199			inp[4] = '\0';
1200		}
1201	}
1202	return (atoi(inp));
1203}
1204
1205/*
1206 * blks_per_ft:  Determine the number of blocks per foot of tape.
1207 * Inter-block gap (dgap) is 0.3 in.
1208 */
1209
1210int
1211blks_per_ft(double disc)
1212{
1213	double dcnt = Blk_cnt, dBpi = Bpi, dsiz = BLKSIZ, dgap = 0.3;
1214
1215	return ((int)(dcnt / (((dcnt * dsiz / dBpi) + dgap) / 12.0) * disc));
1216}
1217
1218/*
1219 * tapeck:  Arbitrary block size.  Determine the number of physical blocks per
1220 * foot of tape, including the inter-block gap, and the possibility of a short
1221 * tape.  Assume the usable portion of a tape is 85% of its length for small
1222 * block sizes and 88% for large block sizes.
1223 */
1224
1225int
1226tapeck(struct file_info *f_p, int dir)
1227{
1228	int again = 1, verify, old_style, new_style;
1229	char resp[16];
1230
1231	errno = 0;
1232	if ((f_p->f_bsize = g_init(&f_p->f_dev, &f_p->f_des)) < 0)
1233		perr(1, "volcopy: Error %d during initialization\n", errno);
1234	if ((f_p->f_dev != G_TM_TAPE) && (f_p->f_dev != G_XT_TAPE) &&
1235	    (f_p->f_dev != G_ST_TAPE))
1236		return (0);
1237	V_labl.v_magic[0] = '\0';	/* scribble on old data */
1238	alarm(5);
1239	if (g_read(f_p->f_dev, f_p->f_des, &V_labl, sizeof (V_labl)) <= 0) {
1240		if (dir == INPUT)
1241			perror("input tape");
1242		else
1243			perror("output tape");
1244	}
1245	alarm(0);
1246	if (V_labl.v_reel == '\0' && dir == INPUT)
1247		perr(9, "Input tape is empty\n");
1248	else {
1249		old_style = strncmp(V_labl.v_magic, "Volcopy", 7) == 0;
1250		new_style = strncmp(V_labl.v_magic, "VOLCOPY", 7) == 0;
1251		if (!old_style && !new_style) {
1252			verify = (dir == INPUT) ? 0 : 1;
1253			prompt(verify, "Not a labeled tape\n");
1254			if (dir == INPUT)
1255				perr(10, "Input tape not made by volcopy\n");
1256			mklabel();
1257			strncpy(V_labl.v_volume, f_p->f_vol_p, 6);
1258			Osup.fs_time = 0;
1259		} else if (new_style) {
1260			Eomflg = (dir == INPUT) ? 1 : Eomflg;
1261			if (!Eomflg)
1262				strncpy(V_labl.v_magic, "Volcopy", 7);
1263		}
1264	}
1265	if (*f_p->f_vol_p == '-')
1266		strncpy(f_p->f_vol_p, V_labl.v_volume, 6);
1267	else if (NOT_EQ(V_labl.v_volume, f_p->f_vol_p, 6)) {
1268		prompt(1, "Header volume(%.6s) does not match (%s)\n",
1269			V_labl.v_volume, f_p->f_vol_p);
1270		strncpy(V_labl.v_volume, f_p->f_vol_p, 6);
1271	}
1272	if (dir == INPUT) {
1273		Bpi = V_labl.v_dens;
1274		if (!Eomflg) {
1275			R_len = V_labl.v_length;
1276			R_num = V_labl.v_reels;
1277		}
1278		if (M3b15) {
1279			if (V_labl.v_type == T_TYPE) {
1280				if (V_labl.v_nblocks == 0) {
1281					Blk_cnt = 10;
1282					Drive_typ = C_DRIVE;
1283				} else
1284					Blk_cnt = V_labl.v_nblocks;
1285				if (V_labl.v_nblocks == 32)
1286					Drive_typ = A_DRIVE;
1287				else
1288					Drive_typ = 0;
1289			} else {
1290				Drive_typ = 0;
1291				Blk_cnt = 10;
1292				Drive_typ = C_DRIVE;
1293			}
1294		}
1295	}
1296	while (!Eomflg && (R_len <= 0 || R_len > 3600)) {
1297		(void) printf(gettext(
1298			"Enter size of reel in feet for <%s>:   "),
1299				f_p->f_vol_p);
1300		fgets(resp, 10, Devtty);
1301		R_len = atoi(resp);
1302		if (R_len > 0 && R_len <= 3600)
1303			break;
1304		perr(0, "Size of reel must be > 0, <= 3600\n");
1305	}
1306	while (!Eomflg && again) {
1307		again = 0;
1308		if (!Bpi) {
1309			(void) printf(gettext(
1310				"Tape density? (i.e., 800 | 1600 | 6250)?   "));
1311			fgets(resp, 10, Devtty);
1312			Bpi = getbpi(resp);
1313		}
1314		switch (Bpi) {
1315		case 800:
1316			R_blks = Ft800x10 * R_len;
1317			break;
1318		case 1600:
1319			if (M3b15) {
1320				switch (Blk_cnt) {
1321				case 1: /* Writing a new tape */
1322					if (Drive_typ == A_DRIVE)
1323						R_blks = Ft1600x32 * R_len;
1324					else if (Drive_typ == C_DRIVE)
1325						R_blks = Ft1600x10 * R_len;
1326					else
1327						R_blks = Ft1600x16 * R_len;
1328					break;
1329				case 10:
1330					R_blks = Ft1600x10 * R_len;
1331					break;
1332				case 16:
1333					R_blks = Ft1600x16 * R_len;
1334					break;
1335				case 32:
1336					R_blks = Ft1600x32 * R_len;
1337					break;
1338				default:
1339					if (Blk_cnt < 32)
1340						R_blks = blks_per_ft(0.85);
1341					else
1342						R_blks = blks_per_ft(0.88);
1343					R_blks *= R_len;
1344				} /* Blk_cnt */
1345			} else
1346				R_blks = Ft1600x10 * R_len;
1347			break;
1348		case 6250:
1349			if (M3b15) {
1350				switch (Blk_cnt) {
1351				case 1: /* Writing a new tape */
1352					if (Drive_typ == A_DRIVE)
1353						R_blks = Ft6250x32 * R_len;
1354					else if (Drive_typ == C_DRIVE)
1355						R_blks = Ft6250x10 * R_len;
1356					else
1357						R_blks = Ft6250x16 * R_len;
1358					break;
1359				case 10:
1360					R_blks = Ft6250x10 * R_len;
1361					break;
1362				case 16:
1363					R_blks = Ft6250x16 * R_len;
1364					break;
1365				case 32:
1366					R_blks = Ft6250x32 * R_len;
1367					break;
1368				default:
1369					if (Blk_cnt < 32)
1370						R_blks = blks_per_ft(0.85);
1371					else
1372						R_blks = blks_per_ft(0.88);
1373					R_blks *= R_len;
1374				}
1375			} else
1376				R_blks = Ft6250x50 * R_len;
1377			break;
1378		default:
1379			perr(0, "Bpi must be 800, 1600, or 6250\n");
1380			Bpi = 0;
1381			again = 1;
1382		} /* Bpi */
1383	} /* again */
1384	(void) printf(gettext("\nReel %.6s"), V_labl.v_volume);
1385	if (!Eomflg) {
1386		V_labl.v_length = R_len;
1387		V_labl.v_dens = Bpi;
1388		(void) printf(gettext(", %d feet, %d BPI\n"), R_len, Bpi);
1389	} else
1390		(void) printf(gettext(", ? feet\n"));
1391	return (1);
1392}
1393
1394/*
1395 * hdrck:  Look for and validate a volcopy style tape label.
1396 */
1397
1398int
1399hdrck(int dev, int fd, char *tvol)
1400{
1401	int verify;
1402	struct volcopy_label tlabl;
1403
1404	alarm(15); /* don't scan whole tape for label */
1405	errno = 0;
1406	if (g_read(dev, fd, &tlabl, sizeof (tlabl)) != sizeof (tlabl)) {
1407		alarm(0);
1408		verify = Otape;
1409		prompt(verify, "Cannot read header\n");
1410		if (Itape)
1411			close(fd);
1412		else
1413			strncpy(V_labl.v_volume, tvol, 6);
1414		return (verify);
1415	}
1416	alarm(0);
1417	V_labl.v_reel = tlabl.v_reel;
1418	if (NOT_EQ(tlabl.v_volume, tvol, 6)) {
1419		perr(0, "Volume is <%.6s>, not <%s>.\n", tlabl.v_volume, tvol);
1420		if (ask("Want to override?   ")) {
1421			if (Otape)
1422				strncpy(V_labl.v_volume, tvol, 6);
1423			else
1424				strncpy(tvol, tlabl.v_volume, 6);
1425			return (1);
1426		}
1427		return (0);
1428	}
1429	return (1);
1430}
1431
1432/*
1433 * mklabel:  Zero out and initialize a volcopy label.
1434 */
1435
1436static void
1437mklabel(void)
1438{
1439
1440	(void) memcpy(&V_labl, Empty, sizeof (V_labl));
1441	if (!Eomflg)
1442		(void) strcpy(V_labl.v_magic, "Volcopy");
1443	else
1444		(void) strcpy(V_labl.v_magic, "VOLCOPY");
1445}
1446
1447/*
1448 * rprt:  Report activity to user.
1449 */
1450
1451static void
1452rprt(void)
1453{
1454
1455	if (Itape)
1456		(void) printf(gettext("\nReading "));
1457	else /* Otape */
1458		(void) printf(gettext("\nWriting "));
1459	if (!Eomflg)
1460		(void) printf(gettext(
1461			"REEL %d of %d VOL = %.6s\n"),
1462				R_cur, R_num, In.f_vol_p);
1463	else
1464		(void) printf(gettext(
1465			"REEL %d of ? VOL = %.6s\n"), R_cur, In.f_vol_p);
1466}
1467
1468#ifdef LOG
1469/*
1470 * fslog: Log current activity.
1471 */
1472
1473static int
1474fslog(void)
1475{
1476	FILE *fp = NULL;
1477
1478	fp = fopen("/var/adm/filesave.log", "a");
1479	if (fp == NULL) {
1480		perr(1, "volcopy: cannot open /var/adm/filesave.log\n");
1481	}
1482
1483	fprintf(fp, "%s%c%.6s%c%.6s -> %s%c%.6s%c%.6s on %.24s\n",
1484		In.f_dev_p, ';', Ifname, ';', Ifpack, Out.f_dev_p,
1485		';', Ofname, ';', Ofpack, ctime(&Tvec));
1486	fclose(fp);
1487	return (0);
1488}
1489#endif	/* LOG */
1490
1491/*
1492 * getname:  Get device name.
1493 */
1494
1495void
1496getname(char *nam_p)
1497{
1498	int lastchar;
1499	char nam_buf[21];
1500
1501	nam_buf[0] = '\0';
1502	(void) printf(gettext("Changing drives? (type RETURN for no,\n"));
1503	(void) printf(gettext("\t`/dev/rmt/??\' or `/dev/rtp/??\' for yes: "));
1504	fgets(nam_buf, 20, Devtty);
1505	nam_buf[20] = '\0';
1506	lastchar = strlen(nam_buf) - 1;
1507	if (nam_buf[lastchar] == '\n')
1508		nam_buf[lastchar] = '\0'; /* remove it */
1509	if (nam_buf[0] != '\0')
1510		(void) strcpy(nam_p, nam_buf);
1511}
1512
1513/*
1514 * chgreel:  Change reel on end-of-media.
1515 */
1516
1517static void
1518chgreel(struct file_info *f_p, int dir)
1519{
1520	int again = 1, lastchar, temp;
1521	char vol_tmp[11];
1522
1523	R_cur++;
1524	while (again) {
1525		again = 0;
1526		errno = 0;
1527		(void) close(f_p->f_des);
1528		(void) getname(f_p->f_dev_p);
1529		(void) printf(gettext(
1530			"Mount tape %d\nType volume-ID when ready:   "), R_cur);
1531		vol_tmp[0] = '\0';
1532		fgets(vol_tmp, 10, Devtty);
1533		vol_tmp[10] = '\0';
1534		lastchar = strlen(vol_tmp) - 1;
1535		if (vol_tmp[lastchar] == '\n')
1536			vol_tmp[lastchar] = '\0'; /* remove it */
1537		if (vol_tmp[0] != '\0') { /* if null string, use old vol-id */
1538			strncpy(f_p->f_vol_p, vol_tmp, 6);
1539			strncpy(V_labl.v_volume, vol_tmp, 6);
1540		}
1541		errno = 0;
1542		f_p->f_des = open(f_p->f_dev_p, 0);
1543		if (f_p->f_des <= 0 || f_p->f_des > 10) {
1544			if (dir == INPUT)
1545				perror("input ERR");
1546			else
1547				perror("output ERR");
1548		}
1549		errno = 0;
1550		if (g_init(&(f_p->f_dev), &(f_p->f_des)) < 0)
1551			perr(0, "Initialization error %d\n", errno);
1552		if ((f_p->f_dev != G_TM_TAPE) && (f_p->f_dev != G_XT_TAPE) &&
1553		    (f_p->f_dev != G_ST_TAPE)) {
1554			(void) printf(gettext(
1555				"\n'%s' is not a valid device"), f_p->f_dev_p);
1556			(void) printf(gettext(
1557		"\n\tenter device name `/dev/rmt/??\' or `/dev/rtp/??\' :"));
1558			again = 1;
1559			continue;
1560		}
1561		if (!hdrck(f_p->f_dev, f_p->f_des, f_p->f_vol_p)) {
1562			again = 1;
1563			continue;
1564		}
1565		switch (dir) {
1566		case INPUT:
1567			if (V_labl.v_reel != R_cur) {
1568				perr(0, "Need reel %d, label says reel %d\n",
1569				    R_cur, V_labl.v_reel);
1570				again = 1;
1571				continue;
1572			}
1573			break;
1574		case OUTPUT:
1575			V_labl.v_reel = R_cur;
1576			temp = V_labl.v_offset;
1577			V_labl.v_offset /= BUFSIZ;
1578			close(f_p->f_des);
1579			sleep(2);
1580			errno = 0;
1581			f_p->f_des = open(f_p->f_dev_p, 1);
1582			if (f_p->f_des <= 0 || f_p->f_des > 10)
1583				perror("output ERR");
1584			errno = 0;
1585			if (g_init(&(f_p->f_dev), &(f_p->f_des)) < 0)
1586				perr(1, "Initialization error %d\n", errno);
1587			errno = 0;
1588			if (g_write(f_p->f_dev, f_p->f_des, &V_labl,
1589			    sizeof (V_labl)) < 0) {
1590				perr(0, "Cannot re-write header -Try again!\n");
1591				again = 1;
1592				V_labl.v_offset = temp;
1593				continue;
1594			}
1595			V_labl.v_offset = temp;
1596			break;
1597		default:
1598			perr(1, "Impossible case\n");
1599		} /* dir */
1600	} /* again */
1601	rprt();
1602}
1603
1604/*
1605 * perr:  Print error messages.
1606 */
1607
1608static void
1609perr(int severity, const char *fmt, ...)
1610{
1611	va_list ap;
1612
1613	va_start(ap, fmt);
1614	(void) fflush(stdout);
1615	(void) fflush(stderr);
1616	if (severity == 10) {
1617		(void) vfprintf(stdout, gettext(fmt), ap);
1618		(void) fprintf(stdout, gettext(
1619			"\t%d reel(s) completed\n"), --R_cur);
1620		(void) fflush(stdout);
1621		(void) fflush(stderr);
1622		cleanup();
1623		exit(31+9);
1624	}
1625	(void) vfprintf(stderr, gettext(fmt), ap);
1626	(void) fflush(stderr);
1627	va_end(ap);
1628	if (severity > 0) {
1629		(void) cleanup();
1630		exit(31+severity);
1631	}
1632}
1633
1634
1635static void
1636getinfs(int dev, int fd, char *buf)
1637{
1638	int cnt;
1639	int i;
1640
1641	if (lseek(fd, SBLOCK * DEV_BSIZE, 0) != SBLOCK * DEV_BSIZE) {
1642		perr(10, "Unable to lseek on input\n");
1643	}
1644	cnt = SBSIZE/DEV_BSIZE;
1645	for (i = 0; i < cnt; i++) {
1646		if (g_read(dev, fd, (char *)buf + i*DEV_BSIZE, DEV_BSIZE)
1647			!= DEV_BSIZE) {
1648			perr(10, "Unable to read on input\n");
1649		}
1650	}
1651}
1652
1653static void
1654getoutfs(int dev, int fd, char *buf, int verify)
1655{
1656	int cnt;
1657	int i;
1658
1659	errno = 0;
1660	if (lseek(fd, SBLOCK * DEV_BSIZE, 0) != SBLOCK * DEV_BSIZE) {
1661		prompt(verify, "Unable to lseek on output\n", errno);
1662	}
1663	cnt = SBSIZE/DEV_BSIZE;
1664	for (i = 0; i < cnt; i++) {
1665		if (g_read(dev, fd, (char *)buf + i*DEV_BSIZE, DEV_BSIZE)
1666			!= DEV_BSIZE) {
1667			prompt(verify, "Unable to read on output\n", errno);
1668		}
1669	}
1670}
1671
1672static char *
1673getfslabel(struct fs *sb)
1674{
1675	int i;
1676	int blk;
1677
1678	/*
1679	 * is there room for label?
1680	 */
1681
1682	if (sb->fs_cpc <= 0)
1683		return (nolabel);
1684
1685	/*
1686	 * calculate the available blocks for each rotational position
1687	 */
1688	blk = sb->fs_spc * sb->fs_cpc / sb->fs_nspf;
1689	for (i = 0; i < blk; i += sb->fs_frag)
1690		/* void */;
1691	i -= sb->fs_frag;
1692	blk = i / sb->fs_frag;
1693
1694	return ((char *)&(fs_rotbl(sb)[blk]));
1695}
1696
1697static char *
1698getvolabel(struct fs *sb)
1699{
1700	char *p;
1701	int i;
1702
1703	p = getfslabel(sb);
1704
1705	if (p == nolabel || p == NULL)
1706		return (nolabel);
1707
1708	for (i = 0; *p && i < 6; p++, i++)
1709		;
1710	p++;
1711	return (p);
1712}
1713