home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume2 / rtar < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  15.4 KB
  1. From: Arnold Robbins <linus!gatech!arnold>
  2. Subject: Diffs to tar to use a remote system's tape drive
  3. Newsgroups: mod.sources
  4. Approved: john@genrad.UUCP
  5.  
  6. Mod.sources:  Volume 2, Issue 5
  7. Submitted by: Arnold Robbins <linus!gatech!arnold>
  8.  
  9.  
  10. * WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
  11. * tape protocol which rdump and rrestore use.  Unfortunately, the man
  12. * page is *WRONG*.  The author of the routines I'm including originally
  13. * wrote his code just based on the man page, and it didn't work, so he
  14. * went to the rdump source to figure out why.  The only thing he had to
  15. * change was to check for the 'F' return code in addition to the 'E',
  16. * and to separate the various arguments with \n instead of a space.  I
  17. * personally don't think that this is much of a problem, but I wanted to
  18. * point it out.
  19. *
  20. *   Arnold Robbins
  21.  
  22.  
  23. The following context diffs to the 4.2 BSD tar.c and man page allow tar
  24. to read and write tapes on a remote system's tape drive.  The routines
  25. at the end that deal with /etc/rmt across a pipe are general purpose and
  26. in the public domain.
  27.  
  28. It is interesting to note that what rmt(8) says about its protocol, and what
  29. you actually have to do to get it to work are quite different.
  30.  
  31. The command line syntax has not changed.  Instead, the file name for the -f
  32. option looks sorta like what rcp takes, e.g.
  33.  
  34.     $ tar -cvf gatech:/dev/rmt8 /usr/src
  35.  
  36. In particular, if "/dev/" does not follow the colon, tar decides it is using
  37. a regular, local file.
  38.  
  39. The diffs are for the tar that comes with BRL Unix. Your line numbers
  40. may vary.
  41.  
  42. Arnold Robbins        (rmt stuff courtesy of Jeff Lee, gatech!jeff)
  43. arnold@gatech.{CSNET, UUCP}
  44. --------------------- cut here ----------------------------
  45. *** /usr/src/bin/tar.c    Wed Nov 14 00:09:23 1984
  46. --- tar.c    Mon Jul  1 14:25:40 1985
  47. ***************
  48. *** 115,120
  49.   char    *getcwd();
  50.   char    *getwd();
  51.   
  52.   main(argc, argv)
  53.   int    argc;
  54.   char    *argv[];
  55.  
  56. --- 115,141 -----
  57.   char    *getcwd();
  58.   char    *getwd();
  59.   
  60. + int    open();
  61. + int    read();
  62. + int    write();
  63. + int    close();
  64. + int    ioctl();
  65. + long    lseek();
  66. + 
  67. + int    rmtopen();
  68. + int    rmtread();
  69. + int    rmtwrite();
  70. + int    rmtclose();
  71. + int    rmtioctl();
  72. + long    rmtlseek();
  73. + 
  74. + int    (*t_open)();
  75. + int    (*t_read)();
  76. + int    (*t_write)();
  77. + int    (*t_close)();
  78. + int    (*t_ioctl)();
  79. + long    (*t_lseek)();
  80. + 
  81.   main(argc, argv)
  82.   int    argc;
  83.   char    *argv[];
  84. ***************
  85. *** 264,269
  86.               nblock);
  87.           done(1);
  88.       }
  89.       if (rflag) {
  90.           if (cflag && tfile != NULL)
  91.               usage();
  92.  
  93. --- 285,293 -----
  94.               nblock);
  95.           done(1);
  96.       }
  97. + 
  98. +     fix_remote();
  99. + 
  100.       if (rflag) {
  101.           if (cflag && tfile != NULL)
  102.               usage();
  103. ***************
  104. *** 285,291
  105.               }
  106.               mt = dup(1);
  107.               nblock = 1;
  108. !         } else if ((mt = open(usefile, 2)) < 0) {
  109.               if (cflag == 0 || (mt =  creat(usefile, 0666)) < 0) {
  110.                   fprintf(stderr,
  111.                       "tar: cannot open %s\n", usefile);
  112.  
  113. --- 309,315 -----
  114.               }
  115.               mt = dup(1);
  116.               nblock = 1;
  117. !         } else if ((mt = (*t_open)(usefile, 2)) < 0) {
  118.               if (cflag == 0 || (mt =  creat(usefile, 0666)) < 0) {
  119.                   fprintf(stderr,
  120.                       "tar: cannot open %s\n", usefile);
  121. ***************
  122. *** 298,304
  123.       if (strcmp(usefile, "-") == 0) {
  124.           mt = dup(0);
  125.           nblock = 1;
  126. !     } else if ((mt = open(usefile, 0)) < 0) {
  127.           fprintf(stderr, "tar: cannot open %s\n", usefile);
  128.           done(1);
  129.       }
  130.  
  131. --- 322,328 -----
  132.       if (strcmp(usefile, "-") == 0) {
  133.           mt = dup(0);
  134.           nblock = 1;
  135. !     } else if ((mt = (*t_open)(usefile, 0)) < 0) {
  136.           fprintf(stderr, "tar: cannot open %s\n", usefile);
  137.           done(1);
  138.       }
  139. ***************
  140. *** 306,311
  141.           doxtract(argv);
  142.       else
  143.           dotable();
  144.       done(0);
  145.   }
  146.   
  147.  
  148. --- 330,336 -----
  149.           doxtract(argv);
  150.       else
  151.           dotable();
  152. +     (*t_close) (mt);
  153.       done(0);
  154.   }
  155.   
  156. ***************
  157. *** 1195,1201
  158.   {
  159.       first = 1;
  160.       if (recno >= nblock) {
  161. !         if (write(mt, tbuf, TBLOCK*nblock) < 0) {
  162.               fprintf(stderr, "tar: tape write error\n");
  163.               done(2);
  164.           }
  165.  
  166. --- 1220,1226 -----
  167.   {
  168.       first = 1;
  169.       if (recno >= nblock) {
  170. !         if ((*t_write)(mt, tbuf, TBLOCK*nblock) < 0) {
  171.               fprintf(stderr, "tar: tape write error\n");
  172.               done(2);
  173.           }
  174. ***************
  175. *** 1209,1215
  176.        *  residual to the tape buffer.
  177.        */
  178.       while (recno == 0 && n >= nblock) {
  179. !         if (write(mt, buffer, TBLOCK*nblock) < 0) {
  180.               fprintf(stderr, "tar: tape write error\n");
  181.               done(2);
  182.           }
  183.  
  184. --- 1234,1240 -----
  185.        *  residual to the tape buffer.
  186.        */
  187.       while (recno == 0 && n >= nblock) {
  188. !         if ((*t_write)(mt, buffer, TBLOCK*nblock) < 0) {
  189.               fprintf(stderr, "tar: tape write error\n");
  190.               done(2);
  191.           }
  192. ***************
  193. *** 1221,1227
  194.           bcopy(buffer, (char *)&tbuf[recno++], TBLOCK);
  195.           buffer += TBLOCK;
  196.           if (recno >= nblock) {
  197. !             if (write(mt, tbuf, TBLOCK*nblock) < 0) {
  198.                   fprintf(stderr, "tar: tape write error\n");
  199.                   done(2);
  200.               }
  201.  
  202. --- 1246,1252 -----
  203.           bcopy(buffer, (char *)&tbuf[recno++], TBLOCK);
  204.           buffer += TBLOCK;
  205.           if (recno >= nblock) {
  206. !             if ((*t_write)(mt, tbuf, TBLOCK*nblock) < 0) {
  207.                   fprintf(stderr, "tar: tape write error\n");
  208.                   done(2);
  209.               }
  210. ***************
  211. *** 1240,1246
  212.       struct mtget mtget;
  213.   
  214.       if (mtdev == 1)
  215. !         mtdev = ioctl(mt, MTIOCGET, &mtget);
  216.       if (mtdev == 0) {
  217.           if (ioctl(mt, MTIOCTOP, &mtop) < 0) {
  218.               fprintf(stderr, "tar: tape backspace error\n");
  219.  
  220. --- 1265,1271 -----
  221.       struct mtget mtget;
  222.   
  223.       if (mtdev == 1)
  224. !         mtdev = (*t_ioctl)(mt, MTIOCGET, &mtget);
  225.       if (mtdev == 0) {
  226.           if ((*t_ioctl)(mt, MTIOCTOP, &mtop) < 0) {
  227.               fprintf(stderr, "tar: tape backspace error\n");
  228. ***************
  229. *** 1242,1248
  230.       if (mtdev == 1)
  231.           mtdev = ioctl(mt, MTIOCGET, &mtget);
  232.       if (mtdev == 0) {
  233. !         if (ioctl(mt, MTIOCTOP, &mtop) < 0) {
  234.               fprintf(stderr, "tar: tape backspace error\n");
  235.               done(4);
  236.           }
  237.  
  238. --- 1267,1273 -----
  239.       if (mtdev == 1)
  240.           mtdev = (*t_ioctl)(mt, MTIOCGET, &mtget);
  241.       if (mtdev == 0) {
  242. !         if ((*t_ioctl)(mt, MTIOCTOP, &mtop) < 0) {
  243.               fprintf(stderr, "tar: tape backspace error\n");
  244.               done(4);
  245.           }
  246. ***************
  247. *** 1247,1253
  248.               done(4);
  249.           }
  250.       } else
  251. !         lseek(mt, (long) -TBLOCK*nblock, 1);
  252.       recno--;
  253.   }
  254.   
  255.  
  256. --- 1272,1278 -----
  257.               done(4);
  258.           }
  259.       } else
  260. !         (*t_lseek)(mt, (long) -TBLOCK*nblock, 1);
  261.       recno--;
  262.   }
  263.   
  264. ***************
  265. *** 1253,1259
  266.   
  267.   flushtape()
  268.   {
  269. !     write(mt, tbuf, TBLOCK*nblock);
  270.   }
  271.   
  272.   bread(fd, buf, size)
  273.  
  274. --- 1278,1284 -----
  275.   
  276.   flushtape()
  277.   {
  278. !     (*t_write)(mt, tbuf, TBLOCK*nblock);
  279.   }
  280.   
  281.   bread(fd, buf, size)
  282. ***************
  283. *** 1265,1271
  284.       static int lastread = 0;
  285.   
  286.       if (!Bflag)
  287. !         return (read(fd, buf, size));
  288.       for (count = 0; count < size; count += lastread) {
  289.           if (lastread < 0) {
  290.               if (count > 0)
  291.  
  292. --- 1290,1296 -----
  293.       static int lastread = 0;
  294.   
  295.       if (!Bflag)
  296. !         return ((*t_read)(fd, buf, size));
  297.       for (count = 0; count < size; count += lastread) {
  298.           if (lastread < 0) {
  299.               if (count > 0)
  300. ***************
  301. *** 1272,1278
  302.                   return (count);
  303.               return (lastread);
  304.           }
  305. !         lastread = read(fd, buf, size - count);
  306.           buf += lastread;
  307.       }
  308.       return (count);
  309.  
  310. --- 1297,1303 -----
  311.                   return (count);
  312.               return (lastread);
  313.           }
  314. !         lastread = (*t_read)(fd, buf, size - count);
  315.           buf += lastread;
  316.       }
  317.       return (count);
  318. ***************
  319. *** 1288,1291
  320.           exit(1);
  321.       }
  322.       return (buf);
  323.   }
  324.  
  325. --- 1313,1758 -----
  326.           exit(1);
  327.       }
  328.       return (buf);
  329. + }
  330. + 
  331. + fix_remote ()
  332. + {
  333. +     char *cp, *index ();
  334. + 
  335. +     if ((cp = index (usefile, ':')) == NULL ||
  336. +         strncmp (cp + 1, "/dev/", 5) != 0)
  337. +     {
  338. +         t_open = open;
  339. +         t_read = read;
  340. +         t_write = write;
  341. +         t_close = close;
  342. +         t_ioctl = ioctl;
  343. +         t_lseek = lseek;
  344. +     }
  345. +     else
  346. +     {
  347. +         t_open = rmtopen;
  348. +         t_read = rmtread;
  349. +         t_write = rmtwrite;
  350. +         t_close = rmtclose;
  351. +         t_ioctl = rmtioctl;
  352. +         t_lseek = rmtlseek;
  353. +     }
  354. + }
  355. + 
  356. + /*
  357. + *    rmt --- remote tape emulator subroutines
  358. + *
  359. + *    Originally written by Jeff Lee, modified some by Arnold Robbins
  360. + */
  361. + 
  362. + /* these are included above, except setjmp.h */
  363. + /*
  364. + #include <stdio.h>
  365. + #include <errno.h>
  366. + #include <setjmp.h>
  367. + #include <signal.h>
  368. + 
  369. + #include <sys/types.h>
  370. + #include <sys/ioctl.h>
  371. + #include <sys/mtio.h>
  372. + */
  373. + 
  374. + #include <setjmp.h>
  375. + 
  376. + /*
  377. + *    MAXUNIT --- Maximum number of remote tape file units
  378. + *
  379. + *    READ --- Return the number of the read side file descriptor
  380. + *    WRITE --- Return the number of the write side file descriptor
  381. + */
  382. + 
  383. + #define MAXUNIT    4
  384. + 
  385. + #define READ(fd)    (Ctp[fd][0])
  386. + #define WRITE(fd)    (Ptc[fd][1])
  387. + 
  388. + static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  389. + static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  390. + 
  391. + jmp_buf Jmpbuf;
  392. + extern int errno;
  393. + 
  394. + 
  395. + 
  396. + /*
  397. + *    abort --- close off a remote tape connection
  398. + */
  399. + 
  400. + static abort(tfd)
  401. + int tfd;
  402. + {
  403. +     close(READ(tfd));
  404. +     close(WRITE(tfd));
  405. +     READ(tfd) = -1;
  406. +     WRITE(tfd) = -1;
  407. + }
  408. + 
  409. + 
  410. + 
  411. + /*
  412. + *    command --- attempt to perform a remote tape command
  413. + */
  414. + 
  415. + static command(tfd, buf)
  416. + char *buf;
  417. + int tfd;
  418. + {
  419. +     int blen;
  420. +     int (*pstat)();
  421. + 
  422. + /*
  423. + *    save current pipe status and try to make the request
  424. + */
  425. + 
  426. +     blen = strlen(buf);
  427. +     pstat = signal(SIGPIPE, SIG_IGN);
  428. +     if (write(WRITE(tfd), buf, blen) == blen)
  429. +     {
  430. +         signal(SIGPIPE, pstat);
  431. +         return(0);
  432. +     }
  433. + 
  434. + /*
  435. + *    something went wrong. close down and go home
  436. + */
  437. + 
  438. +     signal(SIGPIPE, pstat);
  439. +     abort(tfd);
  440. + 
  441. +     errno = EIO;
  442. +     return(-1);
  443. + }
  444. + 
  445. + 
  446. + 
  447. + /*
  448. + *    status --- retrieve the status from the pipe
  449. + */
  450. + 
  451. + static status(tfd)
  452. + int tfd;
  453. + {
  454. +     int i;
  455. +     char c, *cp;
  456. +     char buf[64];
  457. + 
  458. + /*
  459. + *    read the reply command line
  460. + */
  461. + 
  462. +     for (i = 0, cp = buf; i < 64; i++, cp++)
  463. +     {
  464. +         if (read(READ(tfd), cp, 1) != 1)
  465. +         {
  466. +             abort(tfd);
  467. +             errno = EIO;
  468. +             return(-1);
  469. +         }
  470. +         if (*cp == '\n')
  471. +         {
  472. +             *cp = 0;
  473. +             break;
  474. +         }
  475. +     }
  476. + 
  477. +     if (i == 64)
  478. +     {
  479. +         abort(tfd);
  480. +         errno = EIO;
  481. +         return(-1);
  482. +     }
  483. + 
  484. + /*
  485. + *    check the return status
  486. + */
  487. + 
  488. +     for (cp = buf; *cp; cp++)
  489. +         if (*cp != ' ')
  490. +             break;
  491. + 
  492. +     if (*cp == 'E' || *cp == 'F')
  493. +     {
  494. +         errno = atoi(cp + 1);
  495. +         while (read(READ(tfd), &c, 1) == 1)
  496. +             if (c == '\n')
  497. +                 break;
  498. + 
  499. +         if (*cp == 'F')
  500. +             abort(tfd);
  501. + 
  502. +         return(-1);
  503. +     }
  504. + 
  505. + /*
  506. + *    check for mis-synced pipes
  507. + */
  508. + 
  509. +     if (*cp != 'A')
  510. +     {
  511. +         abort(tfd);
  512. +         errno = EIO;
  513. +         return(-1);
  514. +     }
  515. + 
  516. +     return(atoi(cp + 1));
  517. + }
  518. + 
  519. + 
  520. + 
  521. + /*
  522. + *    rmtopen --- open a magtape device on system specified
  523. + */
  524. + 
  525. + rmtopen(dev, mode)
  526. + char *dev;
  527. + int mode;
  528. + {
  529. +     int i, rc;
  530. +     char buf[64];
  531. +     char *sys;
  532. + 
  533. + /*
  534. + *    first, find an open pair of file descriptors
  535. + */
  536. + 
  537. +     for (i = 0; i < MAXUNIT; i++)
  538. +         if (READ(i) == -1 && WRITE(i) == -1)
  539. +             break;
  540. + 
  541. +     if (i == MAXUNIT)
  542. +     {
  543. +         errno = EMFILE;
  544. +         return(-1);
  545. +     }
  546. + 
  547. + /*
  548. + *    pull apart system and device
  549. + */
  550. +     for (sys = dev; *dev != ':'; dev++)
  551. +         ;
  552. +     *dev++ = '\0';
  553. + 
  554. + /*
  555. + *    setup the pipes for the 'rsh' command and fork
  556. + */
  557. + 
  558. +     if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
  559. +         return(-1);
  560. + 
  561. +     if ((rc = fork()) == -1)
  562. +         return(-1);
  563. + 
  564. +     if (rc == 0)
  565. +     {
  566. +         close(0);
  567. +         dup(Ptc[i][0]);
  568. +         close(Ptc[i][0]); close(Ptc[i][1]);
  569. +         close(1);
  570. +         dup(Ctp[i][1]);
  571. +         close(Ctp[i][0]); close(Ctp[i][1]);
  572. + 
  573. +         execl("/usr/ucb/rsh", "rsh", sys, "/etc/rmt", (char *) 0);
  574. + 
  575. + /*
  576. + *    bad problems if we get here
  577. + */
  578. + 
  579. +         perror("exec");
  580. +         exit(1);
  581. +     }
  582. + 
  583. +     close(Ptc[i][0]); close(Ctp[i][1]);
  584. + 
  585. + /*
  586. + *    now attempt to open the tape device
  587. + */
  588. + 
  589. +     sprintf(buf, "O%s\n%d\n", dev, mode);
  590. +     if (command(i, buf) == -1 || status(i) == -1)
  591. +         return(-1);
  592. + 
  593. +     return(i);
  594. + }
  595. + 
  596. + 
  597. + 
  598. + /*
  599. + *    rmtclose --- close a remote magtape unit and shut down
  600. + */
  601. + 
  602. + rmtclose(tfd)
  603. + int tfd;
  604. + {
  605. +     int rc;
  606. + 
  607. +     if (command(tfd, "C\n") != -1)
  608. +     {
  609. +         rc = status(tfd);
  610. + 
  611. +         abort(tfd);
  612. +         return(rc);
  613. +     }
  614. + 
  615. +     return(-1);
  616. + }
  617. + 
  618. + 
  619. + 
  620. + /*
  621. + *    rmtread --- read a buffer from a remote tape
  622. + */
  623. + 
  624. + rmtread(tfd, data, cnt)
  625. + int tfd, cnt;
  626. + char *data;
  627. + {
  628. +     int rc, i;
  629. +     char buf[64];
  630. + 
  631. +     sprintf(buf, "R%d\n", cnt);
  632. +     if (command(tfd, buf) == -1 || (rc = status(tfd)) == -1)
  633. +         return(-1);
  634. + 
  635. +     for (i = 0; i < rc; i += cnt, data += cnt)
  636. +     {
  637. +         cnt = read(READ(tfd), data, rc);
  638. +         if (cnt <= 0)
  639. +         {
  640. +             abort(tfd);
  641. +             errno = EIO;
  642. +             return(-1);
  643. +         }
  644. +     }
  645. + 
  646. +     return(rc);
  647. + }
  648. + 
  649. + 
  650. + 
  651. + /*
  652. + *    rmtwrite --- write a buffer to the remote tape
  653. + */
  654. + 
  655. + rmtwrite(tfd, data, cnt)
  656. + int tfd, cnt;
  657. + char *data;
  658. + {
  659. +     int rc;
  660. +     char buf[64];
  661. +     int (*pstat)();
  662. + 
  663. +     sprintf(buf, "W%d\n", cnt);
  664. +     if (command(tfd, buf) == -1)
  665. +         return(-1);
  666. + 
  667. +     pstat = signal(SIGPIPE, SIG_IGN);
  668. +     if (write(WRITE(tfd), data, cnt) == cnt)
  669. +         return(status(tfd));
  670. + 
  671. +     abort(tfd);
  672. +     errno = EIO;
  673. +     return(-1);
  674. + }
  675. + 
  676. + 
  677. + 
  678. + /*
  679. + *    rmtlseek --- perform an imitation lseek operation remotely
  680. + */
  681. + 
  682. + rmtlseek(tfd, wh, off)
  683. + int tfd, wh, off;
  684. + {
  685. +     char buf[64];
  686. + 
  687. +     sprintf(buf, "L%d\n%d\n", wh, off);
  688. +     if (command(tfd, buf) == -1)
  689. +         return(-1);
  690. + 
  691. +     return(status(tfd));
  692. + }
  693. + 
  694. + 
  695. + 
  696. + /*
  697. + *    rmtioctl --- perform raw tape operations remotely
  698. + */
  699. + 
  700. + rmtioctl(tfd, op, arg)
  701. + int tfd, op;
  702. + char *arg;
  703. + {
  704. +     char c;
  705. +     int rc, cnt;
  706. +     char buf[64];
  707. + 
  708. + /*
  709. + *    MTIOCOP is the easy one. nothing is transfered in binary
  710. + */
  711. + 
  712. +     if (op == MTIOCTOP)
  713. +     {
  714. +         sprintf(buf, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  715. +             ((struct mtop *) arg)->mt_count);
  716. +         if (command(tfd, buf) == -1)
  717. +             return(-1);
  718. +         return(status(tfd));
  719. +     }
  720. + 
  721. + /*
  722. + *    we can only handle 2 ops, if not the other one, punt
  723. + */
  724. + 
  725. +     if (op != MTIOCGET)
  726. +     {
  727. +         errno = EINVAL;
  728. +         return(-1);
  729. +     }
  730. + 
  731. + /*
  732. + *    grab the status and read it directly into the structure
  733. + *    this assumes that the status buffer is (hopefully) not
  734. + *    padded and that 2 shorts fit in a long without any word
  735. + *    alignment problems, ie - the whole struct is contiguous
  736. + *    NOTE - this is probably NOT a good assumption.
  737. + */
  738. + 
  739. +     if (command(tfd, "S\n") == -1 || (rc = status(tfd)) == -1)
  740. +         return(-1);
  741. + 
  742. +     for (; rc > 0; rc -= cnt, arg += cnt)
  743. +     {
  744. +         cnt = read(READ(tfd), arg, rc);
  745. +         if (cnt <= 0)
  746. +         {
  747. +             abort(tfd);
  748. +             errno = EIO;
  749. +             return(-1);
  750. +         }
  751. +     }
  752. + 
  753. + /*
  754. + *    now we check for byte position. mt_type is a small integer field
  755. + *    (normally) so we will check its magnitude. if it is larger than
  756. + *    256, we will assume that the bytes are swapped and go through
  757. + *    and reverse all the bytes
  758. + */
  759. + 
  760. +     if (((struct mtget *) arg)->mt_type < 256)
  761. +         return(0);
  762. + 
  763. +     for (cnt = 0; cnt < rc; cnt += 2)
  764. +     {
  765. +         c = arg[cnt];
  766. +         arg[cnt] = arg[cnt+1];
  767. +         arg[cnt+1] = c;
  768. +     }
  769. + 
  770. +     return(0);
  771.   }
  772. *** /usr/man/man1/tar.1    Mon Jun 27 00:35:14 1983
  773. --- tar.1    Mon Jul  1 13:51:09 1985
  774. ***************
  775. *** 95,101
  776.   .B f
  777.   .I Tar
  778.   uses the next argument as the name of the archive instead of
  779. ! /dev/rmt?. If the name of the file is `\-', tar writes to standard output or
  780.   reads from standard input, whichever is appropriate. Thus,
  781.   .I tar
  782.   can be used as the head or tail of a filter chain.
  783.  
  784. --- 95,113 -----
  785.   .B f
  786.   .I Tar
  787.   uses the next argument as the name of the archive instead of
  788. ! /dev/rmt?.
  789. ! .sp
  790. ! If the file name has the form
  791. ! .IR system :/dev/???,
  792. ! .I tar
  793. ! will use the tape drive /dev/??? on the remote system
  794. ! .IR system ,
  795. ! via
  796. ! .IR rsh (1),
  797. ! and
  798. ! .IR rmt (8).
  799. ! .sp
  800. ! If the name of the file is `\-', tar writes to standard output or
  801.   reads from standard input, whichever is appropriate. Thus,
  802.   .I tar
  803.   can be used as the head or tail of a filter chain.
  804. ***************
  805. *** 179,181
  806.   The current limit on file name length is 100 characters.
  807.   .br
  808.   There is no way to selectively follow symbolic links.
  809.  
  810. --- 191,195 -----
  811.   The current limit on file name length is 100 characters.
  812.   .br
  813.   There is no way to selectively follow symbolic links.
  814. + .br
  815. + Using a remote system's tape drive can be slow.
  816.  
  817.