Remote mag tape routines
sources-request at genrad.UUCP
sources-request at genrad.UUCP
Tue Jul 30 07:47:17 AEST 1985
Mod.sources: Volume 2, Issue 21
Submitted by: Arnold Robbins <gatech!arnold>
Title: Remote mag tape routines, re-written as a general library (+ tar, dd)
Although the remote mag tape stuff for tar was just posted recently, this
is worth re-posting since it 1) fixes a few bugs, and 2) provides a much more
general facility for accessing remote tape drives. E.g., to fix dd for
remote tape drives, all I had to do was add one line and recompile with
the library.
Credit is given in the man page for the people who did the work.
Enjoy,
Arnold Robbins
CSNET: arnold at gatech ARPA: arnold%gatech.csnet at csnet-relay.arpa
UUCP: { akgua, allegra, hplabs, ihnp4, seismo, ut-sally }!gatech!arnold
--------------------- axe your screen here -----------------------
#!/bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #!/bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# README
# dd.1.DIFF
# dd.c.DIFF
# rmt.h
# rmtlib.c
# rmtops.3
# tar.1.DIFF
# tar.c.DIFF
# This archive created: Mon Jul 29 13:04:33 1985
# By: Arnold Robbins (Pr1mebusters!)
export PATH; PATH=/bin:$PATH
echo shar: extracting "'README'" '(851 characters)'
if test -f 'README'
then
echo shar: over-writing existing file "'README'"
fi
cat << \SHAR_EOF > 'README'
README --- remote mag tape library and diffs for tar(1) and dd(1)
The files in this directory implement a library of routines which allow
a user using the Unix system calls for i/o to transparently access a tape
drive on a remote machine, via rsh(1) and rmt(8).
The files are as follows:
README --- This file.
dd.1.DIFF --- Context diff for dd(1) man page.
dd.c.DIFF --- Context diff for dd.c source code.
tar.1.DIFF --- Context diff for tar(1) man page.
tar.c.DIFF --- Context diff for tar.c source code.
rmt.h --- Remote mag tape include file.
rmtlib.c --- Remote mag tape library source code.
rmtops.3 --- Remote mag tape library man page.
The diffs are for BRL Unix 3.0 (4.2 BSD), your line numbers may vary.
The tar(1) diffs include a fix to keep tar from damaging the file system;
existing directories are removed only if they are empty.
SHAR_EOF
echo shar: extracting "'dd.1.DIFF'" '(1273 characters)'
if test -f 'dd.1.DIFF'
then
echo shar: over-writing existing file "'dd.1.DIFF'"
fi
cat << \SHAR_EOF > 'dd.1.DIFF'
*** /usr/man/man1/dd.1 Mon Apr 4 06:12:26 1983
--- dd.1 Wed Jul 24 12:29:58 1985
***************
*** 23,29
.ns
.TP
if=
! input file name; standard input is default
.br
.ns
.TP
--- 23,45 -----
.ns
.TP
if=
! input file name; standard input is default.
! If the input file name has the form
! .IR system [. user ]:/dev/???,
! then
! .I dd
! will attempt to use the tape drive /dev/??? on the remote system
! .IR system ,
! via
! .IR rsh (1),
! and
! .IR rmt (8).
! The optional
! .I user
! specifies the login name to use on the remote system.
! If it is not given, the current user's login name will be used.
! In all cases, the user must have the appropriate
! access permissions on the remote machine in order for this to work.
.br
.ns
.TP
***************
*** 28,34
.ns
.TP
of=
! output file name; standard output is default
.br
.ns
.TP
--- 44,51 -----
.ns
.TP
of=
! output file name; standard output is default,
! remote file names may be used here as well.
.br
.ns
.TP
***************
*** 203,205
raw disks with bad sectors to insure
.I dd
stays synchronized.
--- 220,224 -----
raw disks with bad sectors to insure
.I dd
stays synchronized.
+ .br
+ Using a remote system's tape drive can be slow.
SHAR_EOF
echo shar: extracting "'dd.c.DIFF'" '(360 characters)'
if test -f 'dd.c.DIFF'
then
echo shar: over-writing existing file "'dd.c.DIFF'"
fi
cat << \SHAR_EOF > 'dd.c.DIFF'
*** /usr/src/bin/dd.c Fri Apr 29 04:20:35 1983
--- dd.c Tue Jul 23 14:13:53 1985
***************
*** 2,7
#include <stdio.h>
#include <signal.h>
#define BIG 2147483647
#define LCASE 01
#define UCASE 02
--- 2,9 -----
#include <stdio.h>
#include <signal.h>
+ #include <rmt.h>
+
#define BIG 2147483647
#define LCASE 01
#define UCASE 02
SHAR_EOF
echo shar: extracting "'rmt.h'" '(904 characters)'
if test -f 'rmt.h'
then
echo shar: over-writing existing file "'rmt.h'"
fi
cat << \SHAR_EOF > 'rmt.h'
/*
* rmt.h
*
* Added routines to replace open(), close(), lseek(), ioctl(), etc.
* The preprocessor can be used to remap these the rmtopen(), etc
* thus minimizing source changes.
*
* This file must be included before <sys/stat.h>, since it redefines
* stat to be rmtstat, so that struct stat xyzzy; declarations work
* properly.
*
* -- Fred Fish (w/some changes by Arnold Robbins)
*/
#ifndef access /* avoid multiple redefinition */
#ifndef lint /* in this case what lint doesn't know won't hurt it */
#define access rmtaccess
#define close rmtclose
#define creat rmtcreat
#define dup rmtdup
#define fcntl rmtfcntl
#define fstat rmtfstat
#define ioctl rmtioctl
#define isatty rmtisatty
#define lseek rmtlseek
#define lstat rmtlstat
#define open rmtopen
#define read rmtread
#define stat rmtstat
#define write rmtwrite
extern long rmtlseek (); /* all the rest are int's */
#endif
#endif
SHAR_EOF
echo shar: extracting "'rmtlib.c'" '(13608 characters)'
if test -f 'rmtlib.c'
then
echo shar: over-writing existing file "'rmtlib.c'"
fi
cat << \SHAR_EOF > 'rmtlib.c'
/*
* rmt --- remote tape emulator subroutines
*
* Originally written by Jeff Lee, modified some by Arnold Robbins
*
* WARNING: The man page rmt(8) for /etc/rmt documents the remote mag
* tape protocol which rdump and rrestore use. Unfortunately, the man
* page is *WRONG*. The author of the routines I'm including originally
* wrote his code just based on the man page, and it didn't work, so he
* went to the rdump source to figure out why. The only thing he had to
* change was to check for the 'F' return code in addition to the 'E',
* and to separate the various arguments with \n instead of a space. I
* personally don't think that this is much of a problem, but I wanted to
* point it out.
* -- Arnold Robbins
*
* Redone as a library that can replace open, read, write, etc, by
* Fred Fish, with some additional work by Arnold Robbins.
*/
/*
* MAXUNIT --- Maximum number of remote tape file units
*
* READ --- Return the number of the read side file descriptor
* WRITE --- Return the number of the write side file descriptor
*/
#define RMTIOCTL 1
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#ifdef RMTIOCTL
#include <sys/ioctl.h>
#include <sys/mtio.h>
#endif
#include <errno.h>
#include <setjmp.h>
#include <sys/stat.h>
#define BUFMAGIC 64 /* a magic number for buffer sizes */
#define MAXUNIT 4
#define READ(fd) (Ctp[fd][0])
#define WRITE(fd) (Ptc[fd][1])
static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
static jmp_buf Jmpbuf;
extern int errno;
/*
* abort --- close off a remote tape connection
*/
static void abort(fildes)
int fildes;
{
close(READ(fildes));
close(WRITE(fildes));
READ(fildes) = -1;
WRITE(fildes) = -1;
}
/*
* command --- attempt to perform a remote tape command
*/
static int command(fildes, buf)
int fildes;
char *buf;
{
register int blen;
int (*pstat)();
/*
* save current pipe status and try to make the request
*/
blen = strlen(buf);
pstat = signal(SIGPIPE, SIG_IGN);
if (write(WRITE(fildes), buf, blen) == blen)
{
signal(SIGPIPE, pstat);
return(0);
}
/*
* something went wrong. close down and go home
*/
signal(SIGPIPE, pstat);
abort(fildes);
errno = EIO;
return(-1);
}
/*
* status --- retrieve the status from the pipe
*/
static int status(fildes)
int fildes;
{
int i;
char c, *cp;
char buffer[BUFMAGIC];
/*
* read the reply command line
*/
for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++)
{
if (read(READ(fildes), cp, 1) != 1)
{
abort(fildes);
errno = EIO;
return(-1);
}
if (*cp == '\n')
{
*cp = 0;
break;
}
}
if (i == BUFMAGIC)
{
abort(fildes);
errno = EIO;
return(-1);
}
/*
* check the return status
*/
for (cp = buffer; *cp; cp++)
if (*cp != ' ')
break;
if (*cp == 'E' || *cp == 'F')
{
errno = atoi(cp + 1);
while (read(READ(fildes), &c, 1) == 1)
if (c == '\n')
break;
if (*cp == 'F')
abort(fildes);
return(-1);
}
/*
* check for mis-synced pipes
*/
if (*cp != 'A')
{
abort(fildes);
errno = EIO;
return(-1);
}
return(atoi(cp + 1));
}
/*
* _rmt_open --- open a magtape device on system specified, as given user
*
* file name has the form system[.user]:/dev/????
*/
#define MAXHOSTLEN 257 /* BSD allows very long host names... */
static int _rmt_open (path, oflag, mode)
char *path;
int oflag;
int mode;
{
int i, rc;
char buffer[BUFMAGIC];
char system[MAXHOSTLEN];
char device[BUFMAGIC];
char login[BUFMAGIC];
char *sys, *dev, *user;
sys = system;
dev = device;
user = login;
/*
* first, find an open pair of file descriptors
*/
for (i = 0; i < MAXUNIT; i++)
if (READ(i) == -1 && WRITE(i) == -1)
break;
if (i == MAXUNIT)
{
errno = EMFILE;
return(-1);
}
/*
* pull apart system and device, and optional user
* don't munge original string
*/
while (*path != '.' && *path != ':') {
*sys++ = *path++;
}
*sys = '\0';
path++;
if (*(path - 1) == '.')
{
while (*path != ':') {
*user++ = *path++;
}
*user = '\0';
path++;
}
else
*user = '\0';
while (*path) {
*dev++ = *path++;
}
*dev = '\0';
/*
* setup the pipes for the 'rsh' command and fork
*/
if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
return(-1);
if ((rc = fork()) == -1)
return(-1);
if (rc == 0)
{
close(0);
dup(Ptc[i][0]);
close(Ptc[i][0]); close(Ptc[i][1]);
close(1);
dup(Ctp[i][1]);
close(Ctp[i][0]); close(Ctp[i][1]);
(void) setuid (getuid ());
(void) setgid (getgid ());
if (*user)
{
execl("/usr/ucb/rsh", "rsh", system, "-l", login,
"/etc/rmt", (char *) 0);
execl("/usr/bin/remsh", "remsh", system, "-l", login,
"/etc/rmt", (char *) 0);
}
else
{
execl("/usr/ucb/rsh", "rsh", system,
"/etc/rmt", (char *) 0);
execl("/usr/bin/remsh", "remsh", system,
"/etc/rmt", (char *) 0);
}
/*
* bad problems if we get here
*/
perror("exec");
exit(1);
}
close(Ptc[i][0]); close(Ctp[i][1]);
/*
* now attempt to open the tape device
*/
sprintf(buffer, "O%s\n%d\n", device, oflag);
if (command(i, buffer) == -1 || status(i) == -1)
return(-1);
return(i);
}
/*
* _rmt_close --- close a remote magtape unit and shut down
*/
static int _rmt_close(fildes)
int fildes;
{
int rc;
if (command(fildes, "C\n") != -1)
{
rc = status(fildes);
abort(fildes);
return(rc);
}
return(-1);
}
/*
* _rmt_read --- read a buffer from a remote tape
*/
static int _rmt_read(fildes, buf, nbyte)
int fildes;
char *buf;
unsigned int nbyte;
{
int rc, i;
char buffer[BUFMAGIC];
sprintf(buffer, "R%d\n", nbyte);
if (command(fildes, buffer) == -1 || (rc = status(fildes)) == -1)
return(-1);
for (i = 0; i < rc; i += nbyte, buf += nbyte)
{
nbyte = read(READ(fildes), buf, rc);
if (nbyte <= 0)
{
abort(fildes);
errno = EIO;
return(-1);
}
}
return(rc);
}
/*
* _rmt_write --- write a buffer to the remote tape
*/
static int _rmt_write(fildes, buf, nbyte)
int fildes;
char *buf;
unsigned int nbyte;
{
int rc;
char buffer[BUFMAGIC];
int (*pstat)();
sprintf(buffer, "W%d\n", nbyte);
if (command(fildes, buffer) == -1)
return(-1);
pstat = signal(SIGPIPE, SIG_IGN);
if (write(WRITE(fildes), buf, nbyte) == nbyte)
{
signal (SIGPIPE, pstat);
return(status(fildes));
}
signal (SIGPIPE, pstat);
abort(fildes);
errno = EIO;
return(-1);
}
/*
* _rmt_lseek --- perform an imitation lseek operation remotely
*/
static long _rmt_lseek(fildes, offset, whence)
int fildes;
long offset;
int whence;
{
char buffer[BUFMAGIC];
sprintf(buffer, "L%d\n%d\n", offset, whence);
if (command(fildes, buffer) == -1)
return(-1);
return(status(fildes));
}
#ifdef RMTIOCTL
/*
* _rmt_ioctl --- perform raw tape operations remotely
*/
static _rmt_ioctl(fildes, op, arg)
int fildes, op;
char *arg;
{
char c;
int rc, cnt;
char buffer[BUFMAGIC];
/*
* MTIOCOP is the easy one. nothing is transfered in binary
*/
if (op == MTIOCTOP)
{
sprintf(buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
((struct mtop *) arg)->mt_count);
if (command(fildes, buffer) == -1)
return(-1);
return(status(fildes));
}
/*
* we can only handle 2 ops, if not the other one, punt
*/
if (op != MTIOCGET)
{
errno = EINVAL;
return(-1);
}
/*
* grab the status and read it directly into the structure
* this assumes that the status buffer is (hopefully) not
* padded and that 2 shorts fit in a long without any word
* alignment problems, ie - the whole struct is contiguous
* NOTE - this is probably NOT a good assumption.
*/
if (command(fildes, "S\n") == -1 || (rc = status(fildes)) == -1)
return(-1);
for (; rc > 0; rc -= cnt, arg += cnt)
{
cnt = read(READ(fildes), arg, rc);
if (cnt <= 0)
{
abort(fildes);
errno = EIO;
return(-1);
}
}
/*
* now we check for byte position. mt_type is a small integer field
* (normally) so we will check its magnitude. if it is larger than
* 256, we will assume that the bytes are swapped and go through
* and reverse all the bytes
*/
if (((struct mtget *) arg)->mt_type < 256)
return(0);
for (cnt = 0; cnt < rc; cnt += 2)
{
c = arg[cnt];
arg[cnt] = arg[cnt+1];
arg[cnt+1] = c;
}
return(0);
}
#endif /* RMTIOCTL */
/*
* Added routines to replace open(), close(), lseek(), ioctl(), etc.
* The preprocessor can be used to remap these the rmtopen(), etc
* thus minimizing source changes:
*
* #ifdef REMOTETAPE
* # define access rmtaccess
* # define close rmtclose
* # define creat rmtcreat
* # define dup rmtdup
* # define fcntl rmtfcntl
* # define fstat rmtfstat
* # define ioctl rmtioctl
* # define isatty rmtisatty
* # define lseek rmtlseek
* # define lstat rmtlstat
* # define open rmtopen
* # define read rmtread
* # define stat rmtstat
* # define write rmtwrite
* # define access rmtaccess
* # define close rmtclose
* # define creat rmtcreat
* # define dup rmtdup
* # define fcntl rmtfcntl
* # define fstat rmtfstat
* # define ioctl rmtioctl
* # define lseek rmtlseek
* # define open rmtopen
* # define read rmtread
* # define stat rmtstat
* # define write rmtwrite
* #endif
*
* -- Fred Fish
*
* ADR --- I set up a <rmt.h> include file for this
*
*/
/*
* Note that local vs remote file descriptors are distinquished
* by adding a bias to the remote descriptors. This is a quick
* and dirty trick that may not be portable to some systems.
*/
#define REM_BIAS 128
/*
* Test pathname to see if it is local or remote. A remote device
* is any string that contains ":/dev/". Returns 1 if remote,
* 0 otherwise.
*/
static int remdev (path)
register char *path;
{
#define strchr index
extern char *strchr ();
if ((path = strchr (path, ':')) != NULL)
{
if (strncmp (path + 1, "/dev/", 5) == 0)
{
return (1);
}
}
return (0);
}
/*
* Open a local or remote file. Looks just like open(2) to
* caller.
*/
int rmtopen (path, oflag, mode)
char *path;
int oflag;
int mode;
{
if (remdev (path))
{
return (_rmt_open (path, oflag, mode) + REM_BIAS);
}
else
{
return (open (path, oflag, mode));
}
}
/*
* Test pathname for specified access. Looks just like access(2)
* to caller.
*/
int rmtaccess (path, amode)
char *path;
int amode;
{
if (remdev (path))
{
return (0); /* Let /etc/rmt find out */
}
else
{
return (access (path, amode));
}
}
/*
* Read from stream. Looks just like read(2) to caller.
*/
int rmtread (fildes, buf, nbyte)
int fildes;
char *buf;
unsigned int nbyte;
{
if (isrmt (fildes))
{
return (_rmt_read (fildes - REM_BIAS, buf, nbyte));
}
else
{
return (read (fildes, buf, nbyte));
}
}
/*
* Write to stream. Looks just like write(2) to caller.
*/
int rmtwrite (fildes, buf, nbyte)
int fildes;
char *buf;
unsigned int nbyte;
{
if (isrmt (fildes))
{
return (_rmt_write (fildes - REM_BIAS, buf, nbyte));
}
else
{
return (write (fildes, buf, nbyte));
}
}
/*
* Perform lseek on file. Looks just like lseek(2) to caller.
*/
long rmtlseek (fildes, offset, whence)
int fildes;
long offset;
int whence;
{
if (isrmt (fildes))
{
return (_rmt_lseek (fildes - REM_BIAS, offset, whence));
}
else
{
return (lseek (fildes, offset, whence));
}
}
/*
* Close a file. Looks just like close(2) to caller.
*/
int rmtclose (fildes)
int fildes;
{
if (isrmt (fildes))
{
return (_rmt_close (fildes - REM_BIAS));
}
else
{
return (close (fildes));
}
}
/*
* Do ioctl on file. Looks just like ioctl(2) to caller.
*/
int rmtioctl (fildes, request, arg)
int fildes, request, arg;
{
if (isrmt (fildes))
{
errno = EOPNOTSUPP;
return (-1); /* For now (fnf) */
}
else
{
return (ioctl (fildes, request, arg));
}
}
/*
* Duplicate an open file descriptor. Looks just like dup(2)
* to caller.
*/
int rmtdup (fildes)
int fildes;
{
if (isrmt (fildes))
{
errno = EOPNOTSUPP;
return (-1); /* For now (fnf) */
}
else
{
return (dup (fildes));
}
}
/*
* Get file status. Looks just like fstat(2) to caller.
*/
int rmtfstat (fildes, buf)
int fildes;
struct stat *buf;
{
if (isrmt (fildes))
{
errno = EOPNOTSUPP;
return (-1); /* For now (fnf) */
}
else
{
return (fstat (fildes, buf));
}
}
/*
* Get file status. Looks just like stat(2) to caller.
*/
int rmtstat (path, buf)
char *path;
struct stat *buf;
{
if (remdev (path))
{
errno = EOPNOTSUPP;
return (-1); /* For now (fnf) */
}
else
{
return (stat (path, buf));
}
}
/*
* Create a file from scratch. Looks just like creat(2) to the caller.
*/
#include <sys/file.h> /* BSD DEPENDANT!!! */
/* #include <fcntl.h> /* use this one for S5 with remote stuff */
int rmtcreat (path, mode)
char *path;
int mode;
{
if (remdev (path))
{
return (rmtopen (path, 1 | O_CREAT, mode));
}
else
{
return (creat (path, mode));
}
}
/*
* Isrmt. Let a programmer know he has a remote device.
*/
int isrmt (fd)
int fd;
{
return (fd >= REM_BIAS);
}
/*
* Rmtfcntl. Do a remote fcntl operation.
*/
int rmtfcntl (fd, cmd, arg)
int fd, cmd, arg;
{
if (isrmt (fd))
{
errno = EOPNOTSUPP;
return (-1);
}
else
{
return (fcntl (fd, cmd, arg));
}
}
/*
* Rmtisatty. Do the isatty function.
*/
int rmtisatty (fd)
int fd;
{
if (isrmt (fd))
return (0);
else
return (isatty (fd));
}
/*
* Get file status, even if symlink. Looks just like lstat(2) to caller.
*/
int rmtlstat (path, buf)
char *path;
struct stat *buf;
{
if (remdev (path))
{
errno = EOPNOTSUPP;
return (-1); /* For now (fnf) */
}
else
{
return (lstat (path, buf));
}
}
SHAR_EOF
echo shar: extracting "'rmtops.3'" '(4071 characters)'
if test -f 'rmtops.3'
then
echo shar: over-writing existing file "'rmtops.3'"
fi
cat << \SHAR_EOF > 'rmtops.3'
.TH RMTOPS 3 local
.SH NAME
rmtops \- access tape drives on remote machines
.SH SYNOPSIS
.nf
#include <rmt.h>
#include <sys/stat.h> /* MUST come after <rmt.h> */
int isrmt (fd)
int fd;
int rmtaccess (file, mode)
char *file;
int mode;
int rmtclose (fd)
int fd;
int rmtcreat (file, mode)
char *file;
int mode;
int rmtdup (fd)
int fd;
int rmtfcntl (fd, cmd, arg)
int fd, cmd, arg;
int rmtfstat (fd, buf)
int fd;
struct stat *buf;
int rmtioctl (fd, request, argp)
int fd, request;
char *argp;
int rmtisatty (fd)
int fd;
long rmtlseek (fd, offset, whence)
int fd, whence;
long offset;
int rmtlstat (file, buf)
char *file;
struct stat *buf;
int rmtopen (file, flags [, mode])
char *file;
int flags, mode;
int rmtread (fd, buf, nbytes)
int fd, nbytes;
char *buf;
int rmtstat (file, buf)
char *file;
struct stat *buf;
int rmtwrite (fd, buf, nbytes)
int fd, nbytes;
char *buf;
.fi
.SH DESCRIPTION
.I Rmtops
provides a simple means of transparently accessing tape drives
on remote machines over the ethernet, via
.IR rsh (1)
and
.IR rmt (8).
These routines are used like their corresponding
system calls, but allow the user to open up a tape drive on a remote
system on which he or she has an account and the appropriate remote
permissions.
.PP
A remote tape drive file name has the form
.sp
.RS
.IR system [. user ]:/dev/???
.RE
.sp
where
.I system
is the remote system,
.I /dev/???
is the particular drive on the remote system (raw, blocked, rewinding,
non-rewinding, etc.), and the optional
.I user
is the login name to be used on the remote system, if different from
the current user's login name.
This corresponds to the remote syntax used by
.IR rcp (1).
.PP
For transparency, the user should include the file
.IR <rmt.h> ,
which has the following defines in it:
.PP
.nf
#define access rmtaccess
#define close rmtclose
#define creat rmtcreat
#define dup rmtdup
#define fcntl rmtfcntl
#define fstat rmtfstat
#define ioctl rmtioctl
#define isatty rmtisatty
#define lseek rmtlseek
#define lstat rmtlstat
#define open rmtopen
#define read rmtread
#define stat rmtstat
#define write rmtwrite
.fi
.PP
This allows the programmer to use
.IR open ,
.IR close ,
.IR read ,
.IR write ,
etc. in their normal fashion, with the
.I rmtops
routines taking care of differentiating between local and remote files.
This file should be included
.I before
including the file
.IR <sys/stat.h> ,
since it redefines the identifier ``stat,'' which is used to declare
objects of type struct stat.
.PP
The routines differentiate between local and remote file descriptors by
adding a bias (currently 128) to the file descriptor of the pipe.
The programmer, if he must know if a file is remote, should use the
.I isrmt
function.
.SH FILES
.TP
.B /usr/lib/librmt.a
Contains the remote tape library. To include the library with a program,
add the flag
.I -lrmt
to the
.IR cc (1)
command line.
.SH SEE ALSO
.IR rcp (1),
.IR rsh (1),
.IR rmt (8),
and the appropriate system calls in section 2.
.SH DIAGNOSTICS
Several of these routines will return -1 and set
.I errno
to EOPNOTSUPP, if they are given a remote file name or a file descriptor
on an open remote file (e.g.,
.IR rmtdup ).
.SH BUGS
See diagnostics above. It is to be hoped that true remote file systems
will eventually appear, and eliminate the need for these routines.
.PP
There is no way to use remote tape drives with the
.IR stdio (3)
package, short of recompiling it entirely to use these routines.
.PP
The
.IR rmt (8)
protocol is not very capable. In particular, it relies on
TCP/IP sockets for error free transmission, and does no data validation
of its own.
.PP
The
.I rmt
program allows no more than 10K bytes to be transferred at one time.
Anymore is truncated.
.SH AUTHORS
Jeff Lee (gatech!jeff) wrote the original routines for accessing
tape drives via
.IR rmt (8).
.PP
Fred Fish (unisoft!fnf) redid them into a general purpose library.
.PP
Arnold Robbins (gatech!arnold) added the ability to specify a user
name on the remote system, the
.I <rmt.h>
include file, this man page,
and cleaned up the library a little.
SHAR_EOF
echo shar: extracting "'tar.1.DIFF'" '(1910 characters)'
if test -f 'tar.1.DIFF'
then
echo shar: over-writing existing file "'tar.1.DIFF'"
fi
cat << \SHAR_EOF > 'tar.1.DIFF'
*** /usr/man/man1/oldtar.1 Mon Jun 27 00:35:14 1983
--- tar.1 Wed Jul 24 12:28:29 1985
***************
*** 78,84
.I tar
does its work silently. The
.B v
! (verbose) option make
.I tar
type the name of each file it treats preceded by the function
letter. With the
--- 78,84 -----
.I tar
does its work silently. The
.B v
! (verbose) option makes
.I tar
type the name of each file it treats preceded by the function
letter. With the
***************
*** 95,101
.B f
.I Tar
uses the next argument as the name of the archive instead of
! /dev/rmt?. If the name of the file is `\-', tar writes to standard output or
reads from standard input, whichever is appropriate. Thus,
.I tar
can be used as the head or tail of a filter chain.
--- 95,120 -----
.B f
.I Tar
uses the next argument as the name of the archive instead of
! /dev/rmt?.
! .sp
! If the file name has the form
! .IR system [. user ]:/dev/???
! .I tar
! will use the tape drive /dev/??? on the remote system
! .IR system ,
! via
! .IR rsh (1),
! and
! .IR rmt (8).
! The optional
! .I user
! portion of the pathname specifies the login name to use on the
! remote system.
! If it is not supplied, the current user's login name will be used.
! In all the cases, the user must have the appropriate
! permissions on the remote machine, in order to use this facility.
! .sp
! If the name of the file is `\-', tar writes to standard output or
reads from standard input, whichever is appropriate. Thus,
.I tar
can be used as the head or tail of a filter chain.
***************
*** 179,181
The current limit on file name length is 100 characters.
.br
There is no way to selectively follow symbolic links.
--- 198,202 -----
The current limit on file name length is 100 characters.
.br
There is no way to selectively follow symbolic links.
+ .br
+ Using a remote system's tape drive can be slow.
SHAR_EOF
echo shar: extracting "'tar.c.DIFF'" '(2026 characters)'
if test -f 'tar.c.DIFF'
then
echo shar: over-writing existing file "'tar.c.DIFF'"
fi
cat << \SHAR_EOF > 'tar.c.DIFF'
*** /usr/src/bin/tar.c Wed Nov 14 00:09:23 1984
--- tar.c Wed Jul 24 12:26:38 1985
***************
*** 27,32
* Tape Archival Program
*/
#include <stdio.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/dir.h>
--- 27,33 -----
* Tape Archival Program
*/
#include <stdio.h>
+ #include <rmt.h> /* remote tape, must come before <sys/stat.h> */
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/dir.h>
***************
*** 306,311
doxtract(argv);
else
dotable();
done(0);
}
--- 307,313 -----
doxtract(argv);
else
dotable();
+ close (mt);
done(0);
}
***************
*** 722,728
if (checkdir(dblock.dbuf.name))
continue;
if (dblock.dbuf.linkflag == '2') {
! unlink(dblock.dbuf.name);
if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
fprintf(stderr, "tar: %s: symbolic link failed\n",
dblock.dbuf.name);
--- 724,736 -----
if (checkdir(dblock.dbuf.name))
continue;
if (dblock.dbuf.linkflag == '2') {
! /*
! * only unlink non-directories or empty directories
! */
! if (rmdir (dblock.dbuf.name) < 0) {
! if (errno == ENOTDIR)
! unlink(dblock.dbuf.name);
! }
if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
fprintf(stderr, "tar: %s: symbolic link failed\n",
dblock.dbuf.name);
***************
*** 749,755
continue;
}
if (dblock.dbuf.linkflag == '1') {
! unlink(dblock.dbuf.name);
if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
fprintf(stderr, "tar: %s: cannot link\n",
dblock.dbuf.name);
--- 757,769 -----
continue;
}
if (dblock.dbuf.linkflag == '1') {
! /*
! * only unlink non-directories or empty directories
! */
! if (rmdir (dblock.dbuf.name) < 0) {
! if (errno == ENOTDIR)
! unlink(dblock.dbuf.name);
! }
if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
fprintf(stderr, "tar: %s: cannot link\n",
dblock.dbuf.name);
SHAR_EOF
# End of shell archive
exit 0
More information about the Mod.sources
mailing list