home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume13 / derez3 / part01 next >
Encoding:
Internet Message Format  |  1988-01-30  |  32.0 KB
  1. Subject:  v13i040:  Derez, remove stale files from system, Part01/02
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: A. Nonymous
  7. Posting-number: Volume 13, Issue 40
  8. Archive-name: derez3/part01
  9.  
  10. [  This is kind of a fun program, in a sick sort of way.  Consider it a
  11.    tool in the war between system administrators who believe disks should
  12.    be kept empty, and system users, who believe they should be kept full.
  13.    Sorry, but no summary can do the vilification in the documentation
  14.    true justice; you will have to read the manpage and README yourself.
  15.    --r$  ]
  16.  
  17. This is version 3.0 of Derez, the stale file archiver.
  18.  
  19. This version is an upgraded version of the earlier
  20. usenet posting, from the very same anonymous source.
  21. Several tools to spot anti-social uses have been added,
  22. and the context diff to create a custom version of
  23. 4.2 BSD "tar", called rerez, that remembers access dates
  24. in the tape archive has been added.  This version,
  25. as was the earlier version, is in the public domain
  26. and the author will deny being the author of this program.
  27.  
  28. This is part 1 of two parts.
  29.  
  30. : Run this shell script with "sh" not "csh"
  31. PATH=:/bin:/usr/bin:/usr/ucb
  32. export PATH
  33. all=FALSE
  34. if [ x$1 = x-a ]; then
  35.     all=TRUE
  36. fi
  37. /bin/echo 'Extracting README'
  38. sed 's/^X//' <<'//go.sysin dd *' >README
  39. This code is explicitly placed in the public domain by the author and may be
  40. used for fun or profit (the author really enjoys running it).  It is not
  41. copyrighted and contains no references to the author's true name.  This is
  42. by design as the author does not what to become "known" as the author of Derez.
  43.  
  44. This is version 3.0.  It contains several useful options for derez, a special
  45. version of tar (rerez) to allow archives to restore time last accessed and some
  46. useful tooling to help spot antisocial users.  Derez always wins in the
  47. derez/rerez wars.  What! You think files should remain on disk forever????
  48.  
  49. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  50.  
  51. Caution! Rerez.c is a munged version of 4.2BSD tar and therefore can't
  52. be transmitted to sites without a suitable license.  Any public distributions
  53. of rerez.c should only contain the differences in "patch" format from 4.2BSD
  54. tar to protect AT&T's or UCB's interests.  This distribution contains a file
  55. rerez.c.diff which a context diff to create rerez.c from 4.2BSD tar using
  56. "patch".  Get patch from the USENET archive, or make the changes by hand.
  57. Rerez is simply a version of tar which remembers and restores time last
  58. accessed dates.  If you can't manage to create rerez.c from 4.2BSD tar
  59. send a note to maddog.uucp!root or root@lll-maddog.arpa and we will try
  60. to help you out.
  61.  
  62. The remote tape library patches appearing in rerez are the public
  63. domain rmtlib patches published in the USENET mod.sources.  These
  64. are needed only to access a remote drive.
  65.  
  66. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  67.  
  68. This version of Derez has a Makefile that conforms to the /usr/local
  69. standard for locally developed software (local rules for MadDog).  All binaries
  70. are installed in the /usr/local/{bin,etc,lib,...} directory tree, with the
  71. exception of the man pages due to reservations in munging man (we recently
  72. munged it).  Each installed item can have its owner and group set though the
  73. OWNER and GROUP parameters on the make comand line.  It must be installed once
  74. by root, but there after the owner of the files can maintain them and install
  75. the new versions.
  76.  
  77. Anyone having problems with derez should send a mail request to
  78. maddog!root for possible help or suggestions, arpa sites can use
  79. root@lll-maddog.arpa.  Anyone who fixes some of derez's bugs or inadequacies
  80. is invited to send maddog!root a copy of the patches.  We can always use a
  81. better, but not necessarily less Draconian, derez on our system.
  82.  
  83. Derez does not contain a mechanism to warn users about the impending
  84. removal of stale files.  We have found that doing this only invites the
  85. users to go and defeat the effects of derez totally without archiving
  86. their stale files to tape and removing them from disk.  On systems with
  87. cooperative users, perhaps a separate program that sends users mail about
  88. their stale files, listing their path names might be helpful.
  89.  
  90.  
  91. DIRECTIONS TO SYSTEM ADMINISTRATORS FOR INSTALLATION:
  92. Derez, Readbyte, Rerez, and Agehist have man pages which describe their use
  93. and abuse.  These man pages contain local system rules on MadDog
  94. and you will probably have your own you want to use.  If so, modify
  95. the man pages to reflect these rules.
  96.  
  97. The default definition for staleness is compiled into derez.  You
  98. may want to change this.  In any event the -t option can set the
  99. stale date to anything you want.
  100.  
  101. 1)  Modify the man pages, derez.c and the Makefile to reflect
  102. system rules, default stale interval and installation targets
  103. for your system.
  104.  
  105. 2)  Type "make install" to compile and install all programs and
  106. manual pages.
  107.  
  108. 3) If you take out the #define of RIPEM in derez.c, derez
  109. will create the appropriate directory tree in MORGUE, including
  110. hard links to the target files, but will not rip off the
  111. originals.  You can use this to first check that derez properly
  112. preserves all modes and ownerships before enabling the RIPEM code.
  113. A debug run of derez with the RIPEM code out is highly suggested
  114. to make sure that some system dependency in the code does not bite
  115. you.  Your users expect and deserve absolute reliability when it comes
  116. to archiving their files.
  117.  
  118.  
  119. DIRECTIONS TO SYSTEM ADMINISTRATORS FOR STANDARD USAGE:
  120.  
  121. 1) You must be root to derez another users files.
  122.  
  123. 2) Cd to the directory where the directories you want to run
  124. derez on reside.  Usually this would be the directory where the
  125. login directories of users reside but does not have to be.
  126.     example: cd /u0
  127.  
  128. 2) If the directory MORGUE does not exist, create it.
  129.     example: mkdir MORGUE
  130.  
  131. 3) Suppose you want to search the entire tree under /u0 for stale
  132. files not accessed in a year and move them to MORGUE.  Type the
  133. command:
  134.     derez -t 360
  135. If on the other hand you want to search only the subdirectories
  136. foo and bar and archive their stale files type the command:
  137.     derez -t 360 foo bar
  138. Foo and bar must reside in the current directory.
  139.  
  140. Derez will search the directories for stale files and create
  141. a list of them with the name MORGUE/DEREZ.  It will then
  142. create a link to each file in MORGUE, and if RIPEM is defined
  143. in derez remove the original link one at a time.  Doing this one
  144. files at a time limits the possibility of overrunning the disk.
  145. Using links makes it fast, and does not change the access dates
  146. of the stale files.
  147.  
  148. An entire directory tree of the stale files will eventually be
  149. built in MORGUE.  All of the directories created in MORGUE should
  150. match the originals with respect to ownership and permissions.
  151. Once the process is complete you can archive the directory
  152. tree in MORGUE onto tape using tar, or rerez, and remove the
  153. directory tree.
  154.     cd MORGUE
  155.     rerez c *
  156.     "remove the tape, remove the write ring, then check the
  157.     tape with rerez t to be sure its okay"
  158.     rm -rf *
  159.     "optionally remove the MORGUE directory"
  160.  
  161. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  162. !MAKE TWO COPIES OF THE TAR OR REREZ ARCHIVE, AND CHECK EACH FOR!
  163. !ABSOLUTE FLAWLESSNESS BEFORE BLOWING THOSE FILES AWAY          !
  164. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  165.  
  166. On a system that has never been derez'ed, there may be more than
  167. one tape full of files that are stale by the desired definition of
  168. staleness.  Derez can incrementally be used to build up stale files
  169. until a tar image of the the MORGUE subdirectory will just fill a tape.
  170. First run derez with say, a 3 year definitition of staleness, and
  171. them check the size of MORGUE using:
  172.     du -s MORGUE
  173. Repeat the derez operations with successively smaller intervals until
  174. du reports that a tar image of MORGUE will fill a tape.  When this
  175. happens archive the enmorgued files using tar or rerez and remove the
  176. files in MORGUE.  Repeat this operation until the desired staleness
  177. interval of say a year or less has been reached.
  178.  
  179.  
  180. Remember to create a listing of the files on each archive tape
  181. in a suitable system directory so users can locate any stale files
  182. they need later.  The location of these files and their naming
  183. convention must be duly recorded in the derez man page.
  184. When incrementally building the MORGE as above,
  185. MORGUE/DEREZ will only contain a list of the last set of files
  186. that were enmorgued with derez.  Use "tar t" or "rerez t" to get the
  187. complete archive list from the tape.
  188.  
  189. The rest of this message is the "sh archive format" of the
  190. derez source.
  191. XXXXXXXXXXXXXXXXXXXXX Cut here and feed to /bin/sh XXXXXXXXXXXXXXXXXXX
  192. //go.sysin dd *
  193. if [ `wc -c < README` != 7387 ]; then
  194.     made=FALSE
  195.     /bin/echo 'error transmitting "README" --'
  196.     /bin/echo 'length should be 7387, not' `wc -c < README`
  197. else
  198.     made=TRUE
  199. fi
  200. if [ $made = TRUE ]; then
  201.     /bin/chmod 644 README
  202.     /bin/echo -n '    '; /bin/ls -ld README
  203. fi
  204. /bin/echo 'Extracting Makefile'
  205. sed 's/^X//' <<'//go.sysin dd *' >Makefile
  206. CFLAGS = -O
  207. PROGSRC = derez.c readbyte.c agehist.c
  208. PROGS = derez readbyte agehist rerez
  209. MANS = derez.1 readbyte.1 agehist.1 rerez.1
  210. MANDIR=/usr/local/man
  211.  
  212. OWNER=root
  213. GROUP=daemon
  214.  
  215. all : $P $(PROGS)
  216.  
  217. install : all $(MANS)
  218.     install -c -o $(OWNER) -g $(GROUP) -m 755 derez /usr/local/bin
  219.     install -c -o $(OWNER) -g $(GROUP) -m 644 derez.1 $(MANDIR)/manl/derez.l
  220.     install -c -o $(OWNER) -g $(GROUP) -m 755 readbyte /usr/local/bin
  221.     install -c -o $(OWNER) -g $(GROUP) -m 644 readbyte.1 $(MANDIR)/manl/readbyte.l
  222.     install -c -o $(OWNER) -g $(GROUP) -m 755 agehist /usr/local/bin
  223.     install -c -o $(OWNER) -g $(GROUP) -m 644 agehist.1 $(MANDIR)/manl/agehist.l
  224.     install -c -o $(OWNER) -g $(GROUP) -m 755 rerez /usr/local/bin
  225.     install -c -o $(OWNER) -g $(GROUP) -m 644 rerez.1 $(MANDIR)/manl/rerez.l
  226.  
  227. clean :
  228.     rm -f *.o
  229.  
  230. clobber : clean
  231.     rm -f $(PROGS) scriptfile
  232.  
  233. derez : derez.c
  234.     cc -o derez derez.c
  235. lintderez :
  236.     lint derez.c
  237.  
  238. readbyte : readbyte.c
  239.     cc -o readbyte readbyte.c
  240.  
  241. agehist : agehist.c
  242.     cc -o agehist agehist.c
  243.  
  244. rerez.o : rmt.h
  245.     cc -c -O -I. rerez.c
  246. rerez : rerez.o rmtlib.o
  247.     cc -o rerez rerez.o rmtlib.o
  248.  
  249. scriptfile : README Makefile $(PROGSRC) rerez.c $(MANS)
  250.     touch scriptfile
  251.     rcsdiff -c -r1.1 rerez.c > rerez.c.diff
  252.     cp README scriptfile
  253.     makescript README Makefile $(PROGSRC) rerez.c.diff rmtlib.c rmt.h $(MANS) >> scriptfile
  254.     cp PART1 usenet1
  255.     makescript README Makefile rerez.c.diff rmtlib.c rmt.h >> usenet1
  256.     cp PART2 usenet2
  257.     makescript $(PROGSRC) $(MANS) >> usenet2
  258. //go.sysin dd *
  259. if [ `wc -c < Makefile` != 1478 ]; then
  260.     made=FALSE
  261.     /bin/echo 'error transmitting "Makefile" --'
  262.     /bin/echo 'length should be 1478, not' `wc -c < Makefile`
  263. else
  264.     made=TRUE
  265. fi
  266. if [ $made = TRUE ]; then
  267.     /bin/chmod 644 Makefile
  268.     /bin/echo -n '    '; /bin/ls -ld Makefile
  269. fi
  270. /bin/echo 'Extracting rerez.c.diff'
  271. sed 's/^X//' <<'//go.sysin dd *' >rerez.c.diff
  272. *** /tmp/,RCSt1012366    Sun Dec  6 11:25:29 1987
  273. --- rerez.c    Tue Jun  9 12:52:33 1987
  274. ***************
  275. *** 6,11
  276.    * Tape Archival Program
  277.    */
  278.   #include <stdio.h>
  279.   #include <sys/param.h>
  280.   #include <sys/stat.h>
  281.   #include <sys/dir.h>
  282.  
  283. --- 6,12 -----
  284.    * Tape Archival Program
  285.    */
  286.   #include <stdio.h>
  287. + #include <rmt.h>    /* remote tape, must come before <sys/stat.h> */
  288.   #include <sys/param.h>
  289.   #include <sys/stat.h>
  290.   #include <sys/dir.h>
  291. ***************
  292. *** 28,33
  293.           char gid[8];
  294.           char size[12];
  295.           char mtime[12];
  296.           char chksum[8];
  297.           char linkflag;
  298.           char linkname[NAMSIZ];
  299.  
  300. --- 29,35 -----
  301.           char gid[8];
  302.           char size[12];
  303.           char mtime[12];
  304. +         char atime[12];
  305.           char chksum[8];
  306.           char linkflag;
  307.           char linkname[NAMSIZ];
  308. ***************
  309. *** 82,88
  310.   FILE    *tfile;
  311.   char    tname[] = "/tmp/tarXXXXXX";
  312.   char    *usefile;
  313. ! char    magtape[] = "/dev/rmt8";
  314.   char    *malloc();
  315.   char    *sprintf();
  316.   char    *strcat();
  317.  
  318. --- 84,94 -----
  319.   FILE    *tfile;
  320.   char    tname[] = "/tmp/tarXXXXXX";
  321.   char    *usefile;
  322. ! #ifdef sun
  323. ! char    magtape[] = "/dev/rmt0";
  324. ! #else
  325. ! char    magtape[] = "/dev/rts0";
  326. ! #endif
  327.   char    *malloc();
  328.   char    *sprintf();
  329.   char    *strcat();
  330. ***************
  331. *** 161,166
  332.               break;
  333.   
  334.           case 'm':
  335.               mflag++;
  336.               break;
  337.   
  338.  
  339. --- 167,174 -----
  340.               break;
  341.   
  342.           case 'm':
  343. +             fprintf(stderr, "You must be joking!\n");
  344. +             exit(1);
  345.               mflag++;
  346.               break;
  347.   
  348. ***************
  349. *** 267,272
  350.           doxtract(argv);
  351.       else
  352.           dotable();
  353.       done(0);
  354.   }
  355.   
  356.  
  357. --- 275,281 -----
  358.           doxtract(argv);
  359.       else
  360.           dotable();
  361. +     close (mt);
  362.       done(0);
  363.   }
  364.   
  365. ***************
  366. *** 373,378
  367.       sp->st_gid = i;
  368.       sscanf(dblock.dbuf.size, "%lo", &sp->st_size);
  369.       sscanf(dblock.dbuf.mtime, "%lo", &sp->st_mtime);
  370.       sscanf(dblock.dbuf.chksum, "%o", &chksum);
  371.       if (chksum != (i = checksum())) {
  372.           fprintf(stderr, "tar: directory checksum error (%d != %d)\n",
  373.  
  374. --- 382,388 -----
  375.       sp->st_gid = i;
  376.       sscanf(dblock.dbuf.size, "%lo", &sp->st_size);
  377.       sscanf(dblock.dbuf.mtime, "%lo", &sp->st_mtime);
  378. +     sscanf(dblock.dbuf.atime, "%lo", &sp->st_atime);
  379.       sscanf(dblock.dbuf.chksum, "%o", &chksum);
  380.       if (chksum != (i = checksum())) {
  381.           fprintf(stderr, "tar: directory checksum error (%d != %d)\n",
  382. ***************
  383. *** 557,562
  384.                   }
  385.                   lp->count--;
  386.                   close(infile);
  387.                   return;
  388.               }
  389.               lp = (struct linkbuf *) malloc(sizeof(*lp));
  390.  
  391. --- 567,581 -----
  392.                   }
  393.                   lp->count--;
  394.                   close(infile);
  395. +                 {
  396. +                     struct timeval tv[2];
  397. + 
  398. +                     tv[0].tv_sec = stbuf.st_atime;
  399. +                     tv[0].tv_usec = 0;
  400. +                     tv[1].tv_sec = stbuf.st_mtime;
  401. +                     tv[1].tv_usec = 0;
  402. +                     utimes(shortname, tv);
  403. +                 }
  404.                   return;
  405.               }
  406.               lp = (struct linkbuf *) malloc(sizeof(*lp));
  407. ***************
  408. *** 588,593
  409.               blocks--;
  410.           }
  411.           close(infile);
  412.           if (blocks != 0 || i != 0)
  413.               fprintf(stderr, "tar: %s: file changed size\n",
  414.                   longname);
  415.  
  416. --- 607,621 -----
  417.               blocks--;
  418.           }
  419.           close(infile);
  420. +         {
  421. +             struct timeval tv[2];
  422. + 
  423. +             tv[0].tv_sec = stbuf.st_atime;
  424. +             tv[0].tv_usec = 0;
  425. +             tv[1].tv_sec = stbuf.st_mtime;
  426. +             tv[1].tv_usec = 0;
  427. +             utimes(shortname, tv);
  428. +         }
  429.           if (blocks != 0 || i != 0)
  430.               fprintf(stderr, "tar: %s: file changed size\n",
  431.                   longname);
  432. ***************
  433. *** 642,648
  434.           if (checkdir(dblock.dbuf.name))
  435.               continue;
  436.           if (dblock.dbuf.linkflag == '2') {
  437. !             unlink(dblock.dbuf.name);
  438.               if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
  439.                   fprintf(stderr, "tar: %s: symbolic link failed\n",
  440.                       dblock.dbuf.name);
  441.  
  442. --- 670,682 -----
  443.           if (checkdir(dblock.dbuf.name))
  444.               continue;
  445.           if (dblock.dbuf.linkflag == '2') {
  446. !             /*
  447. !              * only unlink non-directories or empty directories
  448. !              */
  449. !             if (rmdir (dblock.dbuf.name) < 0) {
  450. !                 if (errno == ENOTDIR)
  451. !                     unlink(dblock.dbuf.name);
  452. !             }
  453.               if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
  454.                   fprintf(stderr, "tar: %s: symbolic link failed\n",
  455.                       dblock.dbuf.name);
  456. ***************
  457. *** 657,663
  458.               if (mflag == 0) {
  459.                   struct timeval tv[2];
  460.   
  461. !                 tv[0].tv_sec = time(0);
  462.                   tv[0].tv_usec = 0;
  463.                   tv[1].tv_sec = stbuf.st_mtime;
  464.                   tv[1].tv_usec = 0;
  465.  
  466. --- 691,697 -----
  467.               if (mflag == 0) {
  468.                   struct timeval tv[2];
  469.   
  470. !                 tv[0].tv_sec = stbuf.st_mtime;
  471.                   tv[0].tv_usec = 0;
  472.                   tv[1].tv_sec = stbuf.st_mtime;
  473.                   tv[1].tv_usec = 0;
  474. ***************
  475. *** 669,675
  476.               continue;
  477.           }
  478.           if (dblock.dbuf.linkflag == '1') {
  479. !             unlink(dblock.dbuf.name);
  480.               if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
  481.                   fprintf(stderr, "tar: %s: cannot link\n",
  482.                       dblock.dbuf.name);
  483.  
  484. --- 703,715 -----
  485.               continue;
  486.           }
  487.           if (dblock.dbuf.linkflag == '1') {
  488. !             /*
  489. !              * only unlink non-directories or empty directories
  490. !              */
  491. !             if (rmdir (dblock.dbuf.name) < 0) {
  492. !                 if (errno == ENOTDIR)
  493. !                     unlink(dblock.dbuf.name);
  494. !             }
  495.               if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
  496.                   fprintf(stderr, "tar: %s: cannot link\n",
  497.                       dblock.dbuf.name);
  498. ***************
  499. *** 713,719
  500.           if (mflag == 0) {
  501.               struct timeval tv[2];
  502.   
  503. !             tv[0].tv_sec = time(0);
  504.               tv[0].tv_usec = 0;
  505.               tv[1].tv_sec = stbuf.st_mtime;
  506.               tv[1].tv_usec = 0;
  507.  
  508. --- 753,759 -----
  509.           if (mflag == 0) {
  510.               struct timeval tv[2];
  511.   
  512. !             tv[0].tv_sec = stbuf.st_atime;
  513.               tv[0].tv_usec = 0;
  514.               tv[1].tv_sec = stbuf.st_mtime;
  515.               tv[1].tv_usec = 0;
  516. ***************
  517. *** 761,766
  518.       printf("%7D", st->st_size);
  519.       cp = ctime(&st->st_mtime);
  520.       printf(" %-12.12s %-4.4s ", cp+4, cp+20);
  521.   }
  522.   
  523.   #define    SUID    04000
  524.  
  525. --- 801,808 -----
  526.       printf("%7D", st->st_size);
  527.       cp = ctime(&st->st_mtime);
  528.       printf(" %-12.12s %-4.4s ", cp+4, cp+20);
  529. +     cp = ctime(&st->st_atime);
  530. +     printf(" %-12.12s %-4.4s ", cp+4, cp+20);
  531.   }
  532.   
  533.   #define    SUID    04000
  534. ***************
  535. *** 884,889
  536.       sprintf(dblock.dbuf.gid, "%6o ", sp->st_gid);
  537.       sprintf(dblock.dbuf.size, "%11lo ", sp->st_size);
  538.       sprintf(dblock.dbuf.mtime, "%11lo ", sp->st_mtime);
  539.   }
  540.   
  541.   checksum()
  542.  
  543. --- 926,932 -----
  544.       sprintf(dblock.dbuf.gid, "%6o ", sp->st_gid);
  545.       sprintf(dblock.dbuf.size, "%11lo ", sp->st_size);
  546.       sprintf(dblock.dbuf.mtime, "%11lo ", sp->st_mtime);
  547. +     sprintf(dblock.dbuf.atime, "%11lo ", sp->st_atime);
  548.   }
  549.   
  550.   checksum()
  551. //go.sysin dd *
  552. if [ `wc -c < rerez.c.diff` != 6250 ]; then
  553.     made=FALSE
  554.     /bin/echo 'error transmitting "rerez.c.diff" --'
  555.     /bin/echo 'length should be 6250, not' `wc -c < rerez.c.diff`
  556. else
  557.     made=TRUE
  558. fi
  559. if [ $made = TRUE ]; then
  560.     /bin/chmod 644 rerez.c.diff
  561.     /bin/echo -n '    '; /bin/ls -ld rerez.c.diff
  562. fi
  563. /bin/echo 'Extracting rmtlib.c'
  564. sed 's/^X//' <<'//go.sysin dd *' >rmtlib.c
  565. X/*
  566.  *    rmt --- remote tape emulator subroutines
  567.  *
  568.  *    Originally written by Jeff Lee, modified some by Arnold Robbins
  569.  *
  570.  *    WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
  571.  *    tape protocol which rdump and rrestore use.  Unfortunately, the man
  572.  *    page is *WRONG*.  The author of the routines I'm including originally
  573.  *    wrote his code just based on the man page, and it didn't work, so he
  574.  *    went to the rdump source to figure out why.  The only thing he had to
  575.  *    change was to check for the 'F' return code in addition to the 'E',
  576.  *    and to separate the various arguments with \n instead of a space.  I
  577.  *    personally don't think that this is much of a problem, but I wanted to
  578.  *    point it out.
  579.  *    -- Arnold Robbins
  580.  *
  581.  *    Redone as a library that can replace open, read, write, etc, by
  582.  *    Fred Fish, with some additional work by Arnold Robbins.
  583.  */
  584.  
  585. X/*
  586.  *    MAXUNIT --- Maximum number of remote tape file units
  587.  *
  588.  *    READ --- Return the number of the read side file descriptor
  589.  *    WRITE --- Return the number of the write side file descriptor
  590.  */
  591.  
  592. #define RMTIOCTL    1
  593.  
  594. #include <stdio.h>
  595. #include <signal.h>
  596. #include <sys/types.h>
  597.  
  598. #ifdef RMTIOCTL
  599. #include <sys/ioctl.h>
  600. #include <sys/mtio.h>
  601. #endif
  602.  
  603. #include <errno.h>
  604. #include <setjmp.h>
  605. #include <sys/stat.h>
  606.  
  607. #define BUFMAGIC    64    /* a magic number for buffer sizes */
  608. #define MAXUNIT    4
  609.  
  610. #define READ(fd)    (Ctp[fd][0])
  611. #define WRITE(fd)    (Ptc[fd][1])
  612.  
  613. static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  614. static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  615.  
  616. static jmp_buf Jmpbuf;
  617. extern int errno;
  618.  
  619. X/*
  620.  *    abort --- close off a remote tape connection
  621.  */
  622.  
  623. static void abort(fildes)
  624. int fildes;
  625. {
  626.     close(READ(fildes));
  627.     close(WRITE(fildes));
  628.     READ(fildes) = -1;
  629.     WRITE(fildes) = -1;
  630. }
  631.  
  632.  
  633.  
  634. X/*
  635.  *    command --- attempt to perform a remote tape command
  636.  */
  637.  
  638. static int command(fildes, buf)
  639. int fildes;
  640. char *buf;
  641. {
  642.     register int blen;
  643.     int (*pstat)();
  644.  
  645. X/*
  646.  *    save current pipe status and try to make the request
  647.  */
  648.  
  649.     blen = strlen(buf);
  650.     pstat = signal(SIGPIPE, SIG_IGN);
  651.     if (write(WRITE(fildes), buf, blen) == blen)
  652.     {
  653.         signal(SIGPIPE, pstat);
  654.         return(0);
  655.     }
  656.  
  657. X/*
  658.  *    something went wrong. close down and go home
  659.  */
  660.  
  661.     signal(SIGPIPE, pstat);
  662.     abort(fildes);
  663.  
  664.     errno = EIO;
  665.     return(-1);
  666. }
  667.  
  668.  
  669.  
  670. X/*
  671.  *    status --- retrieve the status from the pipe
  672.  */
  673.  
  674. static int status(fildes)
  675. int fildes;
  676. {
  677.     int i;
  678.     char c, *cp;
  679.     char buffer[BUFMAGIC];
  680.  
  681. X/*
  682.  *    read the reply command line
  683.  */
  684.  
  685.     for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++)
  686.     {
  687.         if (read(READ(fildes), cp, 1) != 1)
  688.         {
  689.             abort(fildes);
  690.             errno = EIO;
  691.             return(-1);
  692.         }
  693.         if (*cp == '\n')
  694.         {
  695.             *cp = 0;
  696.             break;
  697.         }
  698.     }
  699.  
  700.     if (i == BUFMAGIC)
  701.     {
  702.         abort(fildes);
  703.         errno = EIO;
  704.         return(-1);
  705.     }
  706.  
  707. X/*
  708.  *    check the return status
  709.  */
  710.  
  711.     for (cp = buffer; *cp; cp++)
  712.         if (*cp != ' ')
  713.             break;
  714.  
  715.     if (*cp == 'E' || *cp == 'F')
  716.     {
  717.         errno = atoi(cp + 1);
  718.         while (read(READ(fildes), &c, 1) == 1)
  719.             if (c == '\n')
  720.                 break;
  721.  
  722.         if (*cp == 'F')
  723.             abort(fildes);
  724.  
  725.         return(-1);
  726.     }
  727.  
  728. X/*
  729.  *    check for mis-synced pipes
  730.  */
  731.  
  732.     if (*cp != 'A')
  733.     {
  734.         abort(fildes);
  735.         errno = EIO;
  736.         return(-1);
  737.     }
  738.  
  739.     return(atoi(cp + 1));
  740. }
  741.  
  742.  
  743.  
  744. X/*
  745.  *    _rmt_open --- open a magtape device on system specified, as given user
  746.  *
  747.  *    file name has the form system[.user]:/dev/????
  748.  */
  749.  
  750. #define MAXHOSTLEN    257    /* BSD allows very long host names... */
  751.  
  752. static int _rmt_open (path, oflag, mode)
  753. char *path;
  754. int oflag;
  755. int mode;
  756. {
  757.     int i, rc;
  758.     char buffer[BUFMAGIC];
  759.     char system[MAXHOSTLEN];
  760.     char device[BUFMAGIC];
  761.     char login[BUFMAGIC];
  762.     char *sys, *dev, *user;
  763.  
  764.     sys = system;
  765.     dev = device;
  766.     user = login;
  767.  
  768. X/*
  769.  *    first, find an open pair of file descriptors
  770.  */
  771.  
  772.     for (i = 0; i < MAXUNIT; i++)
  773.         if (READ(i) == -1 && WRITE(i) == -1)
  774.             break;
  775.  
  776.     if (i == MAXUNIT)
  777.     {
  778.         errno = EMFILE;
  779.         return(-1);
  780.     }
  781.  
  782. X/*
  783.  *    pull apart system and device, and optional user
  784.  *    don't munge original string
  785.  */
  786.     while (*path != '.' && *path != ':') {
  787.         *sys++ = *path++;
  788.     }
  789.     *sys = '\0';
  790.     path++;
  791.  
  792.     if (*(path - 1) == '.')
  793.     {
  794.         while (*path != ':') {
  795.             *user++ = *path++;
  796.         }
  797.         *user = '\0';
  798.         path++;
  799.     }
  800.     else
  801.         *user = '\0';
  802.  
  803.     while (*path) {
  804.         *dev++ = *path++;
  805.     }
  806.     *dev = '\0';
  807.  
  808. X/*
  809.  *    setup the pipes for the 'rsh' command and fork
  810.  */
  811.  
  812.     if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
  813.         return(-1);
  814.  
  815.     if ((rc = fork()) == -1)
  816.         return(-1);
  817.  
  818.     if (rc == 0)
  819.     {
  820.         close(0);
  821.         dup(Ptc[i][0]);
  822.         close(Ptc[i][0]); close(Ptc[i][1]);
  823.         close(1);
  824.         dup(Ctp[i][1]);
  825.         close(Ctp[i][0]); close(Ctp[i][1]);
  826.         (void) setuid (getuid ());
  827.         (void) setgid (getgid ());
  828.         if (*user)
  829.         {
  830.             execl("/usr/ucb/rsh", "rsh", system, "-l", login,
  831.                 "/etc/rmt", (char *) 0);
  832.             execl("/usr/bin/remsh", "remsh", system, "-l", login,
  833.                 "/etc/rmt", (char *) 0);
  834.         }
  835.         else
  836.         {
  837.             execl("/usr/ucb/rsh", "rsh", system,
  838.                 "/etc/rmt", (char *) 0);
  839.             execl("/usr/bin/remsh", "remsh", system,
  840.                 "/etc/rmt", (char *) 0);
  841.         }
  842.  
  843. X/*
  844.  *    bad problems if we get here
  845.  */
  846.  
  847.         perror("exec");
  848.         exit(1);
  849.     }
  850.  
  851.     close(Ptc[i][0]); close(Ctp[i][1]);
  852.  
  853. X/*
  854.  *    now attempt to open the tape device
  855.  */
  856.  
  857.     sprintf(buffer, "O%s\n%d\n", device, oflag);
  858.     if (command(i, buffer) == -1 || status(i) == -1)
  859.         return(-1);
  860.  
  861.     return(i);
  862. }
  863.  
  864.  
  865.  
  866. X/*
  867.  *    _rmt_close --- close a remote magtape unit and shut down
  868.  */
  869.  
  870. static int _rmt_close(fildes)
  871. int fildes;
  872. {
  873.     int rc;
  874.  
  875.     if (command(fildes, "C\n") != -1)
  876.     {
  877.         rc = status(fildes);
  878.  
  879.         abort(fildes);
  880.         return(rc);
  881.     }
  882.  
  883.     return(-1);
  884. }
  885.  
  886.  
  887.  
  888. X/*
  889.  *    _rmt_read --- read a buffer from a remote tape
  890.  */
  891.  
  892. static int _rmt_read(fildes, buf, nbyte)
  893. int fildes;
  894. char *buf;
  895. unsigned int nbyte;
  896. {
  897.     int rc, i;
  898.     char buffer[BUFMAGIC];
  899.  
  900.     sprintf(buffer, "R%d\n", nbyte);
  901.     if (command(fildes, buffer) == -1 || (rc = status(fildes)) == -1)
  902.         return(-1);
  903.  
  904.     for (i = 0; i < rc; i += nbyte, buf += nbyte)
  905.     {
  906.         nbyte = read(READ(fildes), buf, rc);
  907.         if (nbyte <= 0)
  908.         {
  909.             abort(fildes);
  910.             errno = EIO;
  911.             return(-1);
  912.         }
  913.     }
  914.  
  915.     return(rc);
  916. }
  917.  
  918.  
  919.  
  920. X/*
  921.  *    _rmt_write --- write a buffer to the remote tape
  922.  */
  923.  
  924. static int _rmt_write(fildes, buf, nbyte)
  925. int fildes;
  926. char *buf;
  927. unsigned int nbyte;
  928. {
  929.     int rc;
  930.     char buffer[BUFMAGIC];
  931.     int (*pstat)();
  932.  
  933.     sprintf(buffer, "W%d\n", nbyte);
  934.     if (command(fildes, buffer) == -1)
  935.         return(-1);
  936.  
  937.     pstat = signal(SIGPIPE, SIG_IGN);
  938.     if (write(WRITE(fildes), buf, nbyte) == nbyte)
  939.     {
  940.         signal (SIGPIPE, pstat);
  941.         return(status(fildes));
  942.     }
  943.  
  944.     signal (SIGPIPE, pstat);
  945.     abort(fildes);
  946.     errno = EIO;
  947.     return(-1);
  948. }
  949.  
  950.  
  951.  
  952. X/*
  953.  *    _rmt_lseek --- perform an imitation lseek operation remotely
  954.  */
  955.  
  956. static long _rmt_lseek(fildes, offset, whence)
  957. int fildes;
  958. long offset;
  959. int whence;
  960. {
  961.     char buffer[BUFMAGIC];
  962.  
  963.     sprintf(buffer, "L%d\n%d\n", offset, whence);
  964.     if (command(fildes, buffer) == -1)
  965.         return(-1);
  966.  
  967.     return(status(fildes));
  968. }
  969.  
  970.  
  971. X/*
  972.  *    _rmt_ioctl --- perform raw tape operations remotely
  973.  */
  974.  
  975. #ifdef RMTIOCTL
  976. static _rmt_ioctl(fildes, op, arg)
  977. int fildes, op;
  978. char *arg;
  979. {
  980.     char c;
  981.     int rc, cnt;
  982.     char buffer[BUFMAGIC];
  983.  
  984. X/*
  985.  *    MTIOCOP is the easy one. nothing is transfered in binary
  986.  */
  987.  
  988.     if (op == MTIOCTOP)
  989.     {
  990.         sprintf(buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  991.             ((struct mtop *) arg)->mt_count);
  992.         if (command(fildes, buffer) == -1)
  993.             return(-1);
  994.         return(status(fildes));
  995.     }
  996.  
  997. X/*
  998.  *    we can only handle 2 ops, if not the other one, punt
  999.  */
  1000.  
  1001.     if (op != MTIOCGET)
  1002.     {
  1003.         errno = EINVAL;
  1004.         return(-1);
  1005.     }
  1006.  
  1007. X/*
  1008.  *    grab the status and read it directly into the structure
  1009.  *    this assumes that the status buffer is (hopefully) not
  1010.  *    padded and that 2 shorts fit in a long without any word
  1011.  *    alignment problems, ie - the whole struct is contiguous
  1012.  *    NOTE - this is probably NOT a good assumption.
  1013.  */
  1014.  
  1015.     if (command(fildes, "S\n") == -1 || (rc = status(fildes)) == -1)
  1016.         return(-1);
  1017.  
  1018.     for (; rc > 0; rc -= cnt, arg += cnt)
  1019.     {
  1020.         cnt = read(READ(fildes), arg, rc);
  1021.         if (cnt <= 0)
  1022.         {
  1023.             abort(fildes);
  1024.             errno = EIO;
  1025.             return(-1);
  1026.         }
  1027.     }
  1028.  
  1029. X/*
  1030.  *    now we check for byte position. mt_type is a small integer field
  1031.  *    (normally) so we will check its magnitude. if it is larger than
  1032.  *    256, we will assume that the bytes are swapped and go through
  1033.  *    and reverse all the bytes
  1034.  */
  1035.  
  1036.     if (((struct mtget *) arg)->mt_type < 256)
  1037.         return(0);
  1038.  
  1039.     for (cnt = 0; cnt < rc; cnt += 2)
  1040.     {
  1041.         c = arg[cnt];
  1042.         arg[cnt] = arg[cnt+1];
  1043.         arg[cnt+1] = c;
  1044.     }
  1045.  
  1046.     return(0);
  1047.   }
  1048. #endif /* RMTIOCTL */
  1049.  
  1050. X/*
  1051.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  1052.  *    The preprocessor can be used to remap these the rmtopen(), etc
  1053.  *    thus minimizing source changes:
  1054.  *
  1055.  *        #ifdef <something>
  1056.  *        #  define access rmtaccess
  1057.  *        #  define close rmtclose
  1058.  *        #  define creat rmtcreat
  1059.  *        #  define dup rmtdup
  1060.  *        #  define fcntl rmtfcntl
  1061.  *        #  define fstat rmtfstat
  1062.  *        #  define ioctl rmtioctl
  1063.  *        #  define isatty rmtisatty
  1064.  *        #  define lseek rmtlseek
  1065.  *        #  define lstat rmtlstat
  1066.  *        #  define open rmtopen
  1067.  *        #  define read rmtread
  1068.  *        #  define stat rmtstat
  1069.  *        #  define write rmtwrite
  1070.  *        #  define access rmtaccess
  1071.  *        #  define close rmtclose
  1072.  *        #  define creat rmtcreat
  1073.  *        #  define dup rmtdup
  1074.  *        #  define fcntl rmtfcntl
  1075.  *        #  define fstat rmtfstat
  1076.  *        #  define ioctl rmtioctl
  1077.  *        #  define lseek rmtlseek
  1078.  *        #  define open rmtopen
  1079.  *        #  define read rmtread
  1080.  *        #  define stat rmtstat
  1081.  *        #  define write rmtwrite
  1082.  *        #endif
  1083.  *
  1084.  *    -- Fred Fish
  1085.  *
  1086.  *    ADR --- I set up a <rmt.h> include file for this
  1087.  *
  1088.  */
  1089.  
  1090. X/*
  1091.  *    Note that local vs remote file descriptors are distinquished
  1092.  *    by adding a bias to the remote descriptors.  This is a quick
  1093.  *    and dirty trick that may not be portable to some systems.
  1094.  */
  1095.  
  1096. #define REM_BIAS 128
  1097.  
  1098.  
  1099. X/*
  1100.  *    Test pathname to see if it is local or remote.  A remote device
  1101.  *    is any string that contains ":/dev/".  Returns 1 if remote,
  1102.  *    0 otherwise.
  1103.  */
  1104.  
  1105. static int remdev (path)
  1106. register char *path;
  1107. {
  1108. #define strchr    index
  1109.     extern char *strchr ();
  1110.  
  1111.     if ((path = strchr (path, ':')) != NULL)
  1112.     {
  1113.         if (strncmp (path + 1, "/dev/", 5) == 0)
  1114.         {
  1115.             return (1);
  1116.         }
  1117.     }
  1118.     return (0);
  1119. }
  1120.  
  1121.  
  1122. X/*
  1123.  *    Open a local or remote file.  Looks just like open(2) to
  1124.  *    caller.
  1125.  */
  1126.  
  1127. int rmtopen (path, oflag, mode)
  1128. char *path;
  1129. int oflag;
  1130. int mode;
  1131. {
  1132.     if (remdev (path))
  1133.     {
  1134.         return (_rmt_open (path, oflag, mode) + REM_BIAS);
  1135.     }
  1136.     else
  1137.     {
  1138.         return (open (path, oflag, mode));
  1139.     }
  1140. }
  1141.  
  1142. X/*
  1143.  *    Test pathname for specified access.  Looks just like access(2)
  1144.  *    to caller.
  1145.  */
  1146.  
  1147. int rmtaccess (path, amode)
  1148. char *path;
  1149. int amode;
  1150. {
  1151.     if (remdev (path))
  1152.     {
  1153.         return (0);        /* Let /etc/rmt find out */
  1154.     }
  1155.     else
  1156.     {
  1157.         return (access (path, amode));
  1158.     }
  1159. }
  1160.  
  1161.  
  1162. X/*
  1163.  *    Read from stream.  Looks just like read(2) to caller.
  1164.  */
  1165.   
  1166. int rmtread (fildes, buf, nbyte)
  1167. int fildes;
  1168. char *buf;
  1169. unsigned int nbyte;
  1170. {
  1171.     if (isrmt (fildes))
  1172.     {
  1173.         return (_rmt_read (fildes - REM_BIAS, buf, nbyte));
  1174.     }
  1175.     else
  1176.     {
  1177.         return (read (fildes, buf, nbyte));
  1178.     }
  1179. }
  1180.  
  1181.  
  1182. X/*
  1183.  *    Write to stream.  Looks just like write(2) to caller.
  1184.  */
  1185.  
  1186. int rmtwrite (fildes, buf, nbyte)
  1187. int fildes;
  1188. char *buf;
  1189. unsigned int nbyte;
  1190. {
  1191.     if (isrmt (fildes))
  1192.     {
  1193.         return (_rmt_write (fildes - REM_BIAS, buf, nbyte));
  1194.     }
  1195.     else
  1196.     {
  1197.         return (write (fildes, buf, nbyte));
  1198.     }
  1199. }
  1200.  
  1201. X/*
  1202.  *    Perform lseek on file.  Looks just like lseek(2) to caller.
  1203.  */
  1204.  
  1205. long rmtlseek (fildes, offset, whence)
  1206. int fildes;
  1207. long offset;
  1208. int whence;
  1209. {
  1210.     if (isrmt (fildes))
  1211.     {
  1212.         return (_rmt_lseek (fildes - REM_BIAS, offset, whence));
  1213.     }
  1214.     else
  1215.     {
  1216.         return (lseek (fildes, offset, whence));
  1217.     }
  1218. }
  1219.  
  1220.  
  1221. X/*
  1222.  *    Close a file.  Looks just like close(2) to caller.
  1223.  */
  1224.  
  1225. int rmtclose (fildes)
  1226. int fildes;
  1227. {
  1228.     if (isrmt (fildes))
  1229.     {
  1230.         return (_rmt_close (fildes - REM_BIAS));
  1231.     }
  1232.     else
  1233.     {
  1234.         return (close (fildes));
  1235.     }
  1236. }
  1237.  
  1238. X/*
  1239.  *    Do ioctl on file.  Looks just like ioctl(2) to caller.
  1240.  */
  1241.  
  1242. int rmtioctl (fildes, request, arg)
  1243. int fildes, request, arg;
  1244. {
  1245.     if (isrmt (fildes))
  1246.     {
  1247. #ifdef RMTIOCTL
  1248.         return (_rmt_ioctl (fildes, request, arg));
  1249. #else
  1250.         errno = EOPNOTSUPP;
  1251.         return (-1);        /* For now  (fnf) */
  1252. #endif
  1253.     }
  1254.     else
  1255.     {
  1256.         return (ioctl (fildes, request, arg));
  1257.     }
  1258. }
  1259.  
  1260.  
  1261. X/*
  1262.  *    Duplicate an open file descriptor.  Looks just like dup(2)
  1263.  *    to caller.
  1264.  */
  1265.  
  1266. int rmtdup (fildes)
  1267. int fildes;
  1268. {
  1269.     if (isrmt (fildes))
  1270.     {
  1271.         errno = EOPNOTSUPP;
  1272.         return (-1);        /* For now (fnf) */
  1273.     }
  1274.     else
  1275.     {
  1276.         return (dup (fildes));
  1277.     }
  1278. }
  1279.  
  1280. X/*
  1281.  *    Get file status.  Looks just like fstat(2) to caller.
  1282.  */
  1283.  
  1284. int rmtfstat (fildes, buf)
  1285. int fildes;
  1286. struct stat *buf;
  1287. {
  1288.     if (isrmt (fildes))
  1289.     {
  1290.         errno = EOPNOTSUPP;
  1291.         return (-1);        /* For now (fnf) */
  1292.     }
  1293.     else
  1294.     {
  1295.         return (fstat (fildes, buf));
  1296.     }
  1297. }
  1298.  
  1299.  
  1300. X/*
  1301.  *    Get file status.  Looks just like stat(2) to caller.
  1302.  */
  1303.  
  1304. int rmtstat (path, buf)
  1305. char *path;
  1306. struct stat *buf;
  1307. {
  1308.     if (remdev (path))
  1309.     {
  1310.         errno = EOPNOTSUPP;
  1311.         return (-1);        /* For now (fnf) */
  1312.     }
  1313.     else
  1314.     {
  1315.         return (stat (path, buf));
  1316.     }
  1317. }
  1318.  
  1319.  
  1320.  
  1321. X/*
  1322.  *    Create a file from scratch.  Looks just like creat(2) to the caller.
  1323.  */
  1324.  
  1325. #include <sys/file.h>        /* BSD DEPENDANT!!! */
  1326. X/* #include <fcntl.h>        /* use this one for S5 with remote stuff */
  1327.  
  1328. int rmtcreat (path, mode)
  1329. char *path;
  1330. int mode;
  1331. {
  1332.     if (remdev (path))
  1333.     {
  1334.         return (rmtopen (path, 1 | O_CREAT, mode));
  1335.     }
  1336.     else
  1337.     {
  1338.         return (creat (path, mode));
  1339.     }
  1340. }
  1341.  
  1342. X/*
  1343.  *    Isrmt. Let a programmer know he has a remote device.
  1344.  */
  1345.  
  1346. int isrmt (fd)
  1347. int fd;
  1348. {
  1349.     return (fd >= REM_BIAS);
  1350. }
  1351.  
  1352. X/*
  1353.  *    Rmtfcntl. Do a remote fcntl operation.
  1354.  */
  1355.  
  1356. int rmtfcntl (fd, cmd, arg)
  1357. int fd, cmd, arg;
  1358. {
  1359.     if (isrmt (fd))
  1360.     {
  1361.         errno = EOPNOTSUPP;
  1362.         return (-1);
  1363.     }
  1364.     else
  1365.     {
  1366.         return (fcntl (fd, cmd, arg));
  1367.     }
  1368. }
  1369.  
  1370. X/*
  1371.  *    Rmtisatty.  Do the isatty function.
  1372.  */
  1373.  
  1374. int rmtisatty (fd)
  1375. int fd;
  1376. {
  1377.     if (isrmt (fd))
  1378.         return (0);
  1379.     else
  1380.         return (isatty (fd));
  1381. }
  1382.  
  1383.  
  1384. X/*
  1385.  *    Get file status, even if symlink.  Looks just like lstat(2) to caller.
  1386.  */
  1387.  
  1388. int rmtlstat (path, buf)
  1389. char *path;
  1390. struct stat *buf;
  1391. {
  1392.     if (remdev (path))
  1393.     {
  1394.         errno = EOPNOTSUPP;
  1395.         return (-1);        /* For now (fnf) */
  1396.     }
  1397.     else
  1398.     {
  1399.         return (lstat (path, buf));
  1400.     }
  1401. }
  1402. //go.sysin dd *
  1403. if [ `wc -c < rmtlib.c` != 13684 ]; then
  1404.     made=FALSE
  1405.     /bin/echo 'error transmitting "rmtlib.c" --'
  1406.     /bin/echo 'length should be 13684, not' `wc -c < rmtlib.c`
  1407. else
  1408.     made=TRUE
  1409. fi
  1410. if [ $made = TRUE ]; then
  1411.     /bin/chmod 440 rmtlib.c
  1412.     /bin/echo -n '    '; /bin/ls -ld rmtlib.c
  1413. fi
  1414. /bin/echo 'Extracting rmt.h'
  1415. sed 's/^X//' <<'//go.sysin dd *' >rmt.h
  1416. X/*
  1417.  *    rmt.h
  1418.  *
  1419.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  1420.  *    The preprocessor can be used to remap these the rmtopen(), etc
  1421.  *    thus minimizing source changes.
  1422.  *
  1423.  *    This file must be included before <sys/stat.h>, since it redefines
  1424.  *    stat to be rmtstat, so that struct stat xyzzy; declarations work
  1425.  *    properly.
  1426.  *
  1427.  *    -- Fred Fish (w/some changes by Arnold Robbins)
  1428.  */
  1429.  
  1430.  
  1431. #ifndef access        /* avoid multiple redefinition */
  1432. #ifndef lint        /* in this case what lint doesn't know won't hurt it */
  1433. #define access rmtaccess
  1434. #define close rmtclose
  1435. #define creat rmtcreat
  1436. #define dup rmtdup
  1437. #define fcntl rmtfcntl
  1438. #define fstat rmtfstat
  1439. #define ioctl rmtioctl
  1440. #define isatty rmtisatty
  1441. #define lseek rmtlseek
  1442. #define lstat rmtlstat
  1443. #define open rmtopen
  1444. #define read rmtread
  1445. #define stat rmtstat
  1446. #define write rmtwrite
  1447.  
  1448. extern long rmtlseek ();    /* all the rest are int's */
  1449. #endif
  1450. #endif
  1451. //go.sysin dd *
  1452. if [ `wc -c < rmt.h` != 904 ]; then
  1453.     made=FALSE
  1454.     /bin/echo 'error transmitting "rmt.h" --'
  1455.     /bin/echo 'length should be 904, not' `wc -c < rmt.h`
  1456. else
  1457.     made=TRUE
  1458. fi
  1459. if [ $made = TRUE ]; then
  1460.     /bin/chmod 440 rmt.h
  1461.     /bin/echo -n '    '; /bin/ls -ld rmt.h
  1462. fi
  1463.  
  1464.