home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / gtak / source / 1.10 / buffer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-12  |  37.3 KB  |  1,641 lines
  1. /*****************************************************************************
  2.  * $Id: buffer.c,v 1.7 1993/01/14 21:50:21 ak Exp $
  3.  *****************************************************************************
  4.  * $Log: buffer.c,v $
  5.  * Revision 1.7  1993/01/14  21:50:21  ak
  6.  * EMX 0.8f fixes and enhancements by Kai Uwe Rommel.
  7.  *
  8.  * Revision 1.6  1992/09/29  09:55:27  ak
  9.  * K.U.R., once again :-)
  10.  * - removed a dup() in buffer.c
  11.  * - EMX opendir with hidden/system test in gnu.c (...dotdot)
  12.  *
  13.  * Revision 1.5  1992/09/26  08:32:16  ak
  14.  * *** empty log message ***
  15.  *
  16.  * Revision 1.4  1992/09/22  21:40:17  ak
  17.  * Yet another fix from K.U.R.:
  18.  *  Ich habe noch einen Bug im multi-volume handling gefunden. Die Abfrage
  19.  *  auf ENOSPC und EIO war nicht symmetrisch fuer Lesen und Schreiben.
  20.  *  Multi-Volume-Archive auf floppies konnte man zwar schreiben, aber
  21.  *  nicht lesen.
  22.  *
  23.  * Revision 1.3  1992/09/12  15:57:14  ak
  24.  * - Usenet patches for GNU TAR 1.10
  25.  * - Bugfixes and patches of Kai Uwe Rommel:
  26.  *         filename conversion for FAT
  27.  *         EMX 0.8e
  28.  *         -0..1 alias for a: b:
  29.  *         -2..7 alias for +++TAPE$x
  30.  *
  31.  * Revision 1.2  1992/09/02  20:07:46  ak
  32.  * Version AK200
  33.  * - Tape access
  34.  * - Quick file access
  35.  * - OS/2 extended attributes
  36.  * - Some OS/2 fixes
  37.  * - Some fixes of Kai Uwe Rommel
  38.  *
  39.  * Revision 1.1.1.1  1992/09/02  19:16:58  ak
  40.  * Original GNU Tar 1.10 with some filenames shortened for FAT compliance.
  41.  *
  42.  * Revision 1.1  1992/09/02  19:16:55  ak
  43.  * Initial revision
  44.  *
  45.  *****************************************************************************/
  46.  
  47. static char *rcsid = "$Id: buffer.c,v 1.7 1993/01/14 21:50:21 ak Exp $";
  48.  
  49. /*
  50.  * Modified by Andreas Kaiser July 92.
  51.  * See CHANGES.AK for info.
  52.  */
  53.  
  54. /* Buffer management for tar.
  55.    Copyright (C) 1988 Free Software Foundation
  56.  
  57. This file is part of GNU Tar.
  58.  
  59. GNU Tar is free software; you can redistribute it and/or modify
  60. it under the terms of the GNU General Public License as published by
  61. the Free Software Foundation; either version 1, or (at your option)
  62. any later version.
  63.  
  64. GNU Tar is distributed in the hope that it will be useful,
  65. but WITHOUT ANY WARRANTY; without even the implied warranty of
  66. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  67. GNU General Public License for more details.
  68.  
  69. You should have received a copy of the GNU General Public License
  70. along with GNU Tar; see the file COPYING.  If not, write to
  71. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  72.  
  73. /*
  74.  * Buffer management for tar.
  75.  *
  76.  * Written by John Gilmore, ihnp4!hoptoad!gnu, on 25 August 1985.
  77.  *
  78.  * @(#) buffer.c 1.28 11/6/87 - gnu
  79.  */
  80.  
  81. #include <stdio.h>
  82. #include <ctype.h>
  83. #include <errno.h>
  84. #include <sys/types.h>        /* For non-Berkeley systems */
  85. #include <sys/stat.h>
  86. #include <signal.h>
  87.  
  88. #ifndef MSDOS
  89. #include <sys/ioctl.h>
  90. #if !defined(USG) || defined(HAVE_MTIO)
  91. #include <sys/mtio.h>
  92. #endif
  93. #endif
  94.  
  95. #ifdef    MSDOS
  96. # include <fcntl.h>
  97. # include <process.h>
  98. #else
  99. # ifdef XENIX
  100. #  include <sys/inode.h>
  101. # endif
  102. # include <sys/file.h>
  103. #endif
  104.  
  105. extern int errno;
  106.  
  107. #ifdef OS2
  108. # define INCL_DOSPROCESS
  109. # include <os2.h>
  110. # include <process.h>
  111. # include <string.h>
  112. static int stdio;
  113. #endif
  114.  
  115. #include "tar.h"
  116. #include "port.h"
  117. #include "rmt.h"
  118. #include "regex.h"
  119.  
  120. /* Either stdout or stderr:  The thing we write messages (standard msgs, not
  121.    errors) to.  Stdout unless we're writing a pipe, in which case stderr */
  122. FILE *msg_file = stdout;
  123.  
  124. #define    STDIN    0        /* Standard input  file descriptor */
  125. #define    STDOUT    1        /* Standard output file descriptor */
  126.  
  127. #define    PREAD    0        /* Read  file descriptor from pipe() */
  128. #define    PWRITE    1        /* Write file descriptor from pipe() */
  129.  
  130. #ifdef __STDC__
  131. extern void    *malloc();
  132. extern void    *valloc();
  133. #else
  134. extern char    *malloc();
  135. extern char    *valloc();
  136. #endif
  137. extern time_t time();
  138.  
  139. extern char    *index(), *strcat();
  140. extern char    *strcpy();
  141.  
  142. /*
  143.  * V7 doesn't have a #define for this.
  144.  */
  145. #ifndef O_RDONLY
  146. #define    O_RDONLY    0
  147. #endif
  148. #ifndef O_RDWR
  149. #define O_RDWR        2
  150. #endif
  151. #ifndef O_CREAT
  152. #define O_CREAT        0
  153. #endif
  154. #ifndef O_BINARY
  155. #define O_BINARY    0
  156. #endif
  157.  
  158. #define    MAGIC_STAT    105    /* Magic status returned by child, if
  159.                    it can't exec.  We hope compress/sh
  160.                    never return this status! */
  161.  
  162. void writeerror();
  163. void readerror();
  164.  
  165. void ck_pipe();
  166. void ck_close();
  167.  
  168. extern void finish_header();
  169. extern void to_oct();
  170.  
  171. #ifndef MSDOS
  172. /* Obnoxious test to see if dimwit is trying to dump the archive */
  173. dev_t ar_dev;
  174. ino_t ar_ino;
  175. #endif
  176.  
  177. /*
  178.  * The record pointed to by save_rec should not be overlaid
  179.  * when reading in a new tape block.  Copy it to record_save_area first, and
  180.  * change the pointer in *save_rec to point to record_save_area.
  181.  * Saved_recno records the record number at the time of the save.
  182.  * This is used by annofile() to print the record number of a file's
  183.  * header record.
  184.  */
  185. static union record **save_rec;
  186.  union record record_save_area;
  187. static long        saved_recno;
  188.  
  189. /*
  190.  * PID of child program, if f_compress or remote archive access.
  191.  */
  192. static int    childpid = 0;
  193. #ifdef OS2
  194. static char *    childname;
  195. #endif
  196.  
  197. /*
  198.  * Record number of the start of this block of records
  199.  */
  200. long    baserec;
  201.  
  202. /*
  203.  * Error recovery stuff
  204.  */
  205. static int    r_error_count;
  206.  
  207. /*
  208.  * Have we hit EOF yet?
  209.  */
  210. static int    eof;
  211.  
  212. /* JF we're reading, but we just read the last record and its time to update */
  213. extern time_to_start_writing;
  214. int file_to_switch_to= -1;    /* If remote update, close archive, and use
  215.                    this descriptor to write to */
  216.  
  217. int volno = 1;            /* JF which volume of a multi-volume tape
  218.                    we're on */
  219.  
  220. char *save_name = 0;        /* Name of the file we are currently writing */
  221. long save_totsize;        /* total size of file we are writing.  Only
  222.                    valid if save_name is non_zero */
  223. long save_sizeleft;        /* Where we are in the file we are writing.
  224.                    Only valid if save_name is non-zero */
  225.  
  226. int write_archive_to_stdout;
  227.  
  228. /* Used by fl_read and fl_write to store the real info about saved names */
  229. static char real_s_name[NAMSIZ];
  230. static long real_s_totsize;
  231. static long real_s_sizeleft;
  232.  
  233. /* Reset the EOF flag (if set), and re-set ar_record, etc */
  234.  
  235. void
  236. reset_eof()
  237. {
  238.     if(eof) {
  239.         eof=0;
  240.         ar_record=ar_block;
  241.         ar_last=ar_block+blocking;
  242.         ar_reading=0;
  243.     }
  244. }
  245.  
  246. /*
  247.  * Return the location of the next available input or output record.
  248.  * Return NULL for EOF.  Once we have returned NULL, we just keep returning
  249.  * it, to avoid accidentally going on to the next file on the "tape".
  250.  */
  251. union record *
  252. findrec()
  253. {
  254.     if (ar_record == ar_last) {
  255.         if (eof)
  256.             return (union record *)NULL;    /* EOF */
  257.         flush_archive();
  258.         if (ar_record == ar_last) {
  259.             eof++;
  260.             return (union record *)NULL;    /* EOF */
  261.         }
  262.     }
  263.     return ar_record;
  264. }
  265.  
  266.  
  267. /*
  268.  * Indicate that we have used all records up thru the argument.
  269.  * (should the arg have an off-by-1? XXX FIXME)
  270.  */
  271. void
  272. userec(rec)
  273.     union record *rec;
  274. {
  275.     while(rec >= ar_record)
  276.         ar_record++;
  277.     /*
  278.      * Do NOT flush the archive here.  If we do, the same
  279.      * argument to userec() could mean the next record (if the
  280.      * input block is exactly one record long), which is not what
  281.      * is intended.
  282.      */
  283.     if (ar_record > ar_last)
  284.         abort();
  285. }
  286.  
  287.  
  288. /*
  289.  * Return a pointer to the end of the current records buffer.
  290.  * All the space between findrec() and endofrecs() is available
  291.  * for filling with data, or taking data from.
  292.  */
  293. union record *
  294. endofrecs()
  295. {
  296.     return ar_last;
  297. }
  298.  
  299.  
  300. /*
  301.  * Duplicate a file descriptor into a certain slot.
  302.  * Equivalent to BSD "dup2" with error reporting.
  303.  */
  304. void
  305. dupto(from, to, msg)
  306.     int from, to;
  307.     char *msg;
  308. {
  309.     int err;
  310.  
  311.     if (from != to) {
  312.         err=close(to);
  313.         if(err<0 && errno!=EBADF) {
  314.             msg_perror("Cannot close descriptor %d",to);
  315.             exit(EX_SYSTEM);
  316.         }
  317.         err = dup(from);
  318.         if (err != to) {
  319.             msg_perror("cannot dup %s",msg);
  320.             exit(EX_SYSTEM);
  321.         }
  322.         ck_close(from);
  323.     }
  324. }
  325.  
  326. /* return non-zero if p is the name of a directory */
  327. isfile(p)
  328. char *p;
  329. {
  330.     struct stat stbuf;
  331.  
  332.     if(stat(p,&stbuf)<0)
  333.         return 1;
  334.     if((stbuf.st_mode&S_IFMT)==S_IFREG)
  335.         return 1;
  336.     return 0;
  337. }
  338.  
  339. #ifdef MSDOS
  340. # ifdef OS2
  341.  
  342. int    buffer_size;
  343. int    rmt_fd = -1;
  344.  
  345. void
  346. child_open()
  347. {
  348.     int    save[2];
  349.     int    pipe1[2], pipe2[2];
  350.     int    fd, r, no, a, b, mode;
  351.       char     *compress = (f_zip ? "gzip" : "compress");
  352.  
  353.     if (ar_reading) {
  354.         a = 0;
  355.         b = 1;
  356.         mode = O_RDONLY|O_BINARY;
  357.     } else {
  358.         a = 1;
  359.         b = 0;
  360.         mode = O_WRONLY|O_CREAT|O_TRUNC|O_BINARY;
  361.     }
  362.  
  363.     stdio = (strcmp(ar_file, "-") == 0 || ar_file[0] == 0);
  364.  
  365.     ck_pipe(pipe1);
  366.  
  367.     noinherit(save[b] = dup(b));
  368.  
  369.     if (ar_reading && is_device)
  370.         f_reblock = 1;
  371.  
  372.     if (stdio)
  373.         save[a] = -1;
  374.     else {
  375.         noinherit(save[a] = dup(a));
  376.         close(a);
  377.  
  378.         if ((fd = rmtopen(ar_file, mode, 0666)) < 0) {
  379.             msg_perror("can't open archive %s",ar_file);
  380.             exit(EX_BADARCH);
  381.         }
  382.  
  383.         if (_isrmt(fd)) {
  384.             rmt_fd = fd;
  385.             fd -= __REM_BIAS;
  386.         }
  387.  
  388.         if (fd != a) {
  389.             msg_perror("can't dup archive %s",ar_file);
  390.             exit(EX_BADARCH);
  391.         }
  392.     }
  393.  
  394.     dupto(pipe1[b], b, "pipe");
  395.     inherit(a);
  396.     inherit(b);
  397.     noinherit(pipe1[a]);
  398.  
  399.     if (is_device || f_buffered) {
  400.         if (ar_reading)
  401.             r = spawnlp(P_NOWAIT, "buffer", "buffer", "-i90", "-o0", NULL);
  402.         else {
  403.             char bs[10];
  404.             sprintf(bs, "-b%d", blocksize);
  405.             r = spawnlp(P_NOWAIT, "buffer", "buffer", "-i0", "-o90", bs, NULL);
  406.         }
  407.         if (r < 0) {
  408.             msg_perror("can't spawn buffer");
  409.             exit(EX_SYSTEM);
  410.         }
  411.         childpid = r;
  412.         childname = "buffer";
  413.  
  414.         ck_pipe(pipe2);
  415.         dupto(pipe1[a], a, "pipe");
  416.         dupto(pipe2[b], b, "pipe");
  417.         noinherit(pipe2[a]);
  418.         inherit(a);
  419.         inherit(b);
  420.         r = spawnlp(P_NOWAIT, compress, compress,
  421.             ar_reading ? "-d" : NULL, NULL);
  422.         if (r < 0) {
  423.             msg_perror("can't spawn %s", compress);
  424.             exit(EX_SYSTEM);    
  425.         }
  426.         archive = pipe2[a];
  427.     } else {
  428.         r = spawnlp(P_NOWAIT, compress, compress,
  429.             ar_reading ? "-d" : NULL, NULL);
  430.         if (r < 0) {
  431.             msg_perror("can't spawn %s", compress);
  432.             exit(EX_SYSTEM);    
  433.         }
  434.         archive = pipe1[a];
  435.         childpid = r;
  436.         childname = compress;
  437.     }
  438.  
  439.     if (stdio) {
  440.         if (ar_reading)
  441.             freopen("nul", "r", stdin);
  442.         else
  443.             freopen("nul", "w", stdout);
  444.     }
  445.  
  446.     if (save[0] >= 0)
  447.         dupto(save[0], 0, "saved to stdin");
  448.     if (save[1] >= 0)
  449.         dupto(save[1], 1, "saved to stdout");
  450.     inherit(0);
  451.     inherit(1);
  452. }
  453.  
  454. static void
  455. child_status(int childpid, char *who, int force)
  456. {
  457.     RESULTCODES st;
  458.     PID pid;
  459.  
  460.     if (DosWaitChild(0, 0, &st, &pid, childpid) == 0) {
  461.         switch (st.codeTerminate) {
  462.         case TC_EXIT:
  463.             if (st.codeResult > force)
  464.                 msg("child '%s' return code %d", who, st.codeResult);
  465.             break;
  466.         case TC_HARDERROR:
  467.             msg("child '%s' aborted with hard error", who);
  468.             break;
  469.         case TC_TRAP:
  470.             msg("child '%s' aborted by trap, who");
  471.             break;
  472.         case TC_KILLPROCESS:
  473.             msg("child '%s' killed", who);
  474.             break;
  475.         default:
  476.             msg("child '%s' terminated with unknown status %x.%x",
  477.                 who, st.codeTerminate, st.codeResult);
  478.         }
  479.     }
  480. }
  481.  
  482. void
  483. child_close(force)
  484. {
  485.     if (childpid)
  486.         child_status(childpid, childname, force);
  487. #ifdef DIRECT
  488.     if (rmt_fd >= 0)
  489.         rmtclose(rmt_fd);
  490. #endif
  491.     childpid = 0;
  492. }
  493.  
  494. #else /* MSDOS but not OS2 */
  495.  
  496. void
  497. child_open()
  498. {
  499.     fprintf(stderr,"MSDOS %s can't use compressed or remote archives\n",tar);
  500.     exit(EX_ARGSBAD);
  501. }
  502.  
  503. void
  504. child_close()
  505. {
  506. }
  507.  
  508. # endif /* MSDOS */
  509. #else /* unix */
  510.  
  511. void
  512. child_open()
  513. {
  514.     int pipe[2];
  515.     int err = 0;
  516.  
  517.     int kidpipe[2];
  518.     int kidchildpid;
  519.  
  520.     ck_pipe(pipe);
  521.  
  522.     childpid=fork();
  523.     if(childpid<0) {
  524.         msg_perror("cannot fork");
  525.         exit(EX_SYSTEM);
  526.     }
  527.     if(childpid>0) {
  528.         /* We're the parent.  Clean up and be happy */
  529.         /* This, at least, is easy */
  530.  
  531.         if(ar_reading) {
  532.             f_reblock++;
  533.             archive=pipe[PREAD];
  534.             ck_close(pipe[PWRITE]);
  535.         } else {
  536.             archive = pipe[PWRITE];
  537.             ck_close(pipe[PREAD]);
  538.         }
  539.         return;
  540.     }
  541.  
  542.     /* We're the kid */
  543.     if(ar_reading) {
  544.         dupto(pipe[PWRITE],STDOUT,"(child) pipe to stdout");
  545.         ck_close(pipe[PREAD]);
  546.     } else {
  547.         dupto(pipe[PREAD],STDIN,"(child) pipe to stdin");
  548.         ck_close(pipe[PWRITE]);
  549.     }
  550.  
  551.     /* We need a child tar only if
  552.        1: we're reading/writing stdin/out (to force reblocking)
  553.        2: the file is to be accessed by rmt (compress doesn't know how)
  554.        3: the file is not a plain file */
  555. #ifdef NO_REMOTE
  556.     if(!(ar_file[0]=='-' && ar_file[1]=='\0') && isfile(ar_file))
  557. #else
  558.     if(!(ar_file[0]=='-' && ar_file[1]=='\0') && !_remdev(ar_file) && isfile(ar_file))
  559. #endif
  560.     {
  561.         /* We don't need a child tar.  Open the archive */
  562.         if(ar_reading) {
  563.             archive=open(ar_file, O_RDONLY|O_BINARY, 0666);
  564.             if(archive<0) {
  565.                 msg_perror("can't open archive %s",ar_file);
  566.                 exit(EX_BADARCH);
  567.             }
  568.             dupto(archive,STDIN,"archive to stdin");
  569.             /* close(archive); */
  570.         } else {
  571.             archive=creat(ar_file,0666);
  572.             if(archive<0) {
  573.                 msg_perror("can't open archive %s",ar_file);
  574.                 exit(EX_BADARCH);
  575.             }
  576.             dupto(archive,STDOUT,"archive to stdout");
  577.             /* close(archive); */
  578.         }
  579.     } else {
  580.         /* We need a child tar */
  581.         ck_pipe(kidpipe);
  582.  
  583.         kidchildpid=fork();
  584.         if(kidchildpid<0) {
  585.             msg_perror("child can't fork");
  586.             exit(EX_SYSTEM);
  587.         }
  588.  
  589.         if(kidchildpid>0) {
  590.             /* About to exec compress:  set up the files */
  591.             if(ar_reading) {
  592.                 dupto(kidpipe[PREAD],STDIN,"((child)) pipe to stdin");
  593.                 ck_close(kidpipe[PWRITE]);
  594.                 /* dup2(pipe[PWRITE],STDOUT); */
  595.             } else {
  596.                 /* dup2(pipe[PREAD],STDIN); */
  597.                 dupto(kidpipe[PWRITE],STDOUT,"((child)) pipe to stdout");
  598.                 ck_close(kidpipe[PREAD]);
  599.             }
  600.             /* ck_close(pipe[PREAD]); */
  601.             /* ck_close(pipe[PWRITE]); */
  602.             /* ck_close(kidpipe[PREAD]);
  603.             ck_close(kidpipe[PWRITE]); */
  604.         } else {
  605.         /* Grandchild.  Do the right thing, namely sit here and
  606.            read/write the archive, and feed stuff back to compress */
  607.             tar="tar (child)";
  608.             if(ar_reading) {
  609.                 dupto(kidpipe[PWRITE],STDOUT,"[child] pipe to stdout");
  610.                 ck_close(kidpipe[PREAD]);
  611.             } else {
  612.                 dupto(kidpipe[PREAD],STDIN,"[child] pipe to stdin");
  613.                 ck_close(kidpipe[PWRITE]);
  614.             }
  615.  
  616.             if (ar_file[0] == '-' && ar_file[1] == '\0') {
  617.                 if (ar_reading)
  618.                     archive = STDIN;
  619.                 else
  620.                     archive = STDOUT;
  621.             } else /* This can't happen if (ar_reading==2)
  622.                 archive = rmtopen(ar_file, O_RDWR|O_CREAT|O_BINARY, 0666);
  623.             else */if(ar_reading)
  624.                 archive = rmtopen(ar_file, O_RDONLY|O_BINARY, 0666);
  625.             else
  626.                 archive = rmtcreat(ar_file, 0666);
  627.  
  628.             if (archive < 0) {
  629.                 msg_perror("can't open archive %s",ar_file);
  630.                 exit(EX_BADARCH);
  631.             }
  632.  
  633.             if(ar_reading) {
  634.                 for(;;) {
  635.                     char *ptr;
  636.                     int max,count;
  637.         
  638.                     r_error_count = 0;
  639.                 error_loop:
  640.                     err=rmtread(archive, ar_block->charptr,(int)(blocksize));
  641.                     if(err<0) {
  642.                         readerror();
  643.                         goto error_loop;
  644.                     }
  645.                     if(err==0)
  646.                         break;
  647.                     ptr = ar_block->charptr;
  648.                     max = err;
  649.                     while(max) {
  650.                         count = (max<RECORDSIZE) ? max : RECORDSIZE;
  651.                         err=write(STDOUT,ptr,count);
  652.                         if(err!=count) {
  653.                             if(err<0) {
  654.                                 msg_perror("can't write to compress");
  655.                                 exit(EX_SYSTEM);
  656.                             } else
  657.                                 msg("write to compress short %d bytes",count-err);
  658.                             count = (err<0) ? 0 : err;
  659.                         }
  660.                         ptr+=count;
  661.                         max-=count;
  662.                     }
  663.                 }
  664.             } else {
  665.                 for(;;) {
  666.                     int n;
  667.                     char *ptr;
  668.         
  669.                     n=blocksize;
  670.                     ptr = ar_block->charptr;
  671.                     while(n) {
  672.                         err=read(STDIN,ptr,(n<RECORDSIZE) ? n : RECORDSIZE);
  673.                         if(err<=0)
  674.                             break;
  675.                         n-=err;
  676.                         ptr+=err;
  677.                     }
  678.                         /* EOF */
  679.                     if(err==0) {
  680.                         if(f_compress<2)
  681.                             blocksize-=n;
  682.                         else
  683.                             bzero(ar_block->charptr+blocksize-n,n);
  684.                         err=rmtwrite(archive,ar_block->charptr,blocksize);
  685.                         if(err!=(blocksize))
  686.                             writeerror(err);
  687.                         if(f_compress<2)
  688.                             blocksize+=n;
  689.                         break;
  690.                     }
  691.                     if(n) {
  692.                         msg_perror("can't read from compress");
  693.                         exit(EX_SYSTEM);
  694.                     }
  695.                     err=rmtwrite(archive, ar_block->charptr, (int)blocksize);
  696.                     if(err!=blocksize)
  697.                         writeerror(err);
  698.                 }
  699.             }
  700.         
  701.             /* close_archive(); */
  702.             exit(0);
  703.         }
  704.     }
  705.         /* So we should exec compress (-d) */
  706.     if(ar_reading) {
  707.         execlp("gzip", "gzip", "-d", (char *)0);
  708.         /* Try uncompress if gunzip fails */
  709.         execlp("compress", "compress", "-d", (char *)0);
  710.     } else if (f_zip)
  711.         execlp("gzip", "gzip", "-8", (char *)0);
  712.     else
  713.         execlp("compress", "compress", (char *)0);
  714.     msg_perror("can't exec compress");
  715.     _exit(EX_SYSTEM);
  716. }
  717.  
  718. void
  719. child_close()
  720. {
  721.     int child, status;
  722.  
  723.     if (childpid) {
  724.         /*
  725.          * Loop waiting for the right child to die, or for
  726.          * no more kids.
  727.          */
  728.         while (((child = wait(&status)) != childpid) && child != -1)
  729.             ;
  730.  
  731.         if (child != -1) {
  732.             switch (TERM_SIGNAL(status)) {
  733.             case 0:
  734.                 /* Child voluntarily terminated  -- but why? */
  735.                 if (TERM_VALUE(status) == MAGIC_STAT) {
  736.                     exit(EX_SYSTEM);/* Child had trouble */
  737.                 }
  738.                 if (TERM_VALUE(status) == (SIGPIPE + 128)) {
  739.                     /*
  740.                      * /bin/sh returns this if its child
  741.                      * dies with SIGPIPE.  'Sok.
  742.                      */
  743.                     break;
  744.                 } else if (TERM_VALUE(status))
  745.                     msg("child returned status %d",
  746.                         TERM_VALUE(status));
  747.             case SIGPIPE:
  748.                 break;        /* This is OK. */
  749.  
  750.             default:
  751.                 msg("child died with signal %d%s",
  752.                  TERM_SIGNAL(status),
  753.                  TERM_COREDUMP(status)? " (core dumped)": "");
  754.             }
  755.         }
  756.     }
  757. }
  758. #endif
  759.  
  760. /*
  761.  * Open an archive file.  The argument specifies whether we are
  762.  * reading or writing.
  763.  */
  764. /* JF if the arg is 2, open for reading and writing. */
  765. open_archive(reading)
  766.     int reading;
  767. {
  768.     extern int map_read;
  769.  
  770. #ifdef HOST
  771.     if (f_host && reading)
  772.         host_recv(ar_file);
  773. #endif
  774.  
  775.     msg_file = f_exstdout ? stderr : stdout;
  776.  
  777.     if (blocksize == 0) {
  778.         msg("invalid value for blocksize");
  779.         exit(EX_ARGSBAD);
  780.     }
  781.  
  782.     if(ar_file==0) {
  783.         msg("No archive name given, what should I do?");
  784.         exit(EX_BADARCH);
  785.     }
  786.  
  787.     /*NOSTRICT*/
  788.     if(f_multivol) {
  789.         ar_block = (union record *) valloc((unsigned)(blocksize+(2*RECORDSIZE)));
  790.         if(ar_block)
  791.             ar_block += 2;
  792.     } else
  793.         ar_block = (union record *) valloc((unsigned)blocksize);
  794.     if (!ar_block) {
  795.         msg("could not allocate memory for blocking factor %d",
  796.             blocking);
  797.         exit(EX_ARGSBAD);
  798.     }
  799.  
  800.     ar_record = ar_block;
  801.     ar_last   = ar_block + blocking;
  802.     ar_reading = reading;
  803.  
  804.     if (f_compress) {
  805.         if(reading==2 || f_verify) {
  806.             msg("cannot update or verify compressed archives");
  807.             exit(EX_ARGSBAD);
  808.         }
  809.         child_open();
  810.         if(!reading && ar_file[0]=='-' && ar_file[1]=='\0')
  811.             msg_file = stderr;
  812.         /* child_open(rem_host, rem_file); */
  813.     } else if (ar_file[0] == '-' && ar_file[1] == '\0') {
  814.         f_reblock++;    /* Could be a pipe, be safe */
  815.         if(f_verify) {
  816.             msg("can't verify stdin/stdout archive");
  817.             exit(EX_ARGSBAD);
  818.         }
  819.         if(reading==2) {
  820.             archive=STDIN;
  821.             msg_file=stderr;
  822.             write_archive_to_stdout++;
  823.         } else if (reading)
  824.             archive = STDIN;
  825.         else {
  826.             archive = STDOUT;
  827.             msg_file = stderr;
  828.         }
  829.     } else if (reading==2 || f_verify) {
  830.         archive = rmtopen(ar_file, O_RDWR|O_CREAT|O_BINARY, 0666);
  831.     } else if(reading) {
  832.         archive = rmtopen(ar_file, O_RDONLY|O_BINARY, 0666);
  833.     } else {
  834.         archive = rmtcreat(ar_file, 0666);
  835.     }
  836. #ifndef MSDOS
  837.     if(!_isrmt(archive)) {
  838.         struct stat tmp_stat;
  839.  
  840.         fstat(archive,&tmp_stat);
  841.         if((tmp_stat.st_mode&S_IFMT)==S_IFREG) {
  842.             ar_dev=tmp_stat.st_dev;
  843.             ar_ino=tmp_stat.st_ino;
  844.         }
  845.     }
  846. #endif
  847.  
  848.     if (archive < 0) {
  849.         msg_perror("can't open %s",ar_file);
  850.         exit(EX_BADARCH);
  851.     }
  852. #ifdef    MSDOS
  853.     if (!_isrmt(archive))
  854.         setmode(archive, O_BINARY);
  855. #endif
  856.  
  857.     if (reading) {
  858.         ar_last = ar_block;        /* Set up for 1st block = # 0 */
  859.         if (f_map_file && map_read)
  860.             return;
  861.         (void) findrec();        /* Read it in, check for EOF */
  862.  
  863.         if(f_volhdr) {
  864.             union record *head;
  865. #ifndef REGEX
  866.             char *ptr;
  867.  
  868.             if(f_multivol) {
  869.                 ptr=malloc(strlen(f_volhdr)+20);
  870.                 sprintf(ptr,"%s Volume %d",f_volhdr,1);
  871.             } else
  872.                 ptr=f_volhdr;
  873. #endif
  874.             head=findrec();
  875.             if(!head) {
  876.                 msg("Archive not labelled to match %s",f_volhdr);
  877.                 exit(EX_BADVOL);
  878.             }
  879. #ifdef REGEX
  880.             if (re_match (label_pattern, head->header.name,
  881.                       strlen (head->header.name), 0, 0) < 0) {
  882.                 msg ("Volume mismatch!  %s!=%s", f_volhdr,
  883.                      head->header.name);
  884.                 exit (EX_BADVOL);
  885.             }
  886. #else
  887.             if(strcmp(ptr,head->header.name)) {
  888.                 msg("Volume mismatch!  %s!=%s",ptr,head->header.name);
  889.                 exit(EX_BADVOL);
  890.             }
  891.             if(ptr!=f_volhdr)
  892.                 free(ptr);
  893. #endif
  894.         }
  895.     } else if(f_volhdr) {
  896.         bzero((void *)ar_block,RECORDSIZE);
  897.         if(f_multivol)
  898.             sprintf(ar_block->header.name,"%s Volume 1",f_volhdr);
  899.         else
  900.             strcpy(ar_block->header.name,f_volhdr);
  901.         ar_block->header.linkflag = LF_VOLHDR;
  902.         to_oct(time(0),    1+12, ar_block->header.mtime);
  903.         finish_header(ar_block);
  904.         /* ar_record++; */
  905.     }
  906. }
  907.  
  908.  
  909. /*
  910.  * Remember a union record * as pointing to something that we
  911.  * need to keep when reading onward in the file.  Only one such
  912.  * thing can be remembered at once, and it only works when reading
  913.  * an archive.
  914.  *
  915.  * We calculate "offset" then add it because some compilers end up
  916.  * adding (baserec+ar_record), doing a 9-bit shift of baserec, then
  917.  * subtracting ar_block from that, shifting it back, losing the top 9 bits.
  918.  */
  919. saverec(pointer)
  920.     union record **pointer;
  921. {
  922.     long offset;
  923.  
  924.     save_rec = pointer;
  925.     offset = ar_record - ar_block;
  926.     saved_recno = baserec + offset;
  927. }
  928.  
  929. /*
  930.  * Perform a write to flush the buffer.
  931.  */
  932.  
  933. /*send_buffer_to_file();
  934.   if(new_volume) {
  935.       deal_with_new_volume_stuff();
  936.     send_buffer_to_file();
  937.   }
  938.  */
  939.  
  940. fl_write()
  941. {
  942.     int err;
  943.     int copy_back;
  944.     static long bytes_written = 0;
  945.  
  946.     if(tape_length && bytes_written >= tape_length * 1024) {
  947.         errno = ENOSPC;
  948.         err = 0;
  949.     } else
  950.         err = rmtwrite(archive, ar_block->charptr,(int) blocksize);
  951.     if(err!=blocksize && !f_multivol)
  952.         writeerror(err);
  953.     else if (f_totals)
  954.             tot_written += blocksize;
  955.  
  956.     if(err>0)
  957.         bytes_written+=err;
  958.     if (err == blocksize) {
  959.         if(f_multivol) {
  960.             if(!save_name) {
  961.                 real_s_name[0]='\0';
  962.                 real_s_totsize=0;
  963.                 real_s_sizeleft = 0;
  964.                 return;
  965.             }
  966. #ifdef MSDOS
  967.             if(save_name[1]==':')
  968.                 save_name+=2;
  969. #endif
  970.             while(*save_name=='/')
  971.                 save_name++;
  972.  
  973.              /* strcpy(real_s_name,save_name); */
  974.                         strncpy(real_s_name,save_name,NAMSIZ-1);
  975.                         real_s_name[NAMSIZ]='\0';
  976.             real_s_totsize = save_totsize;
  977.             real_s_sizeleft = save_sizeleft;
  978.         }
  979.         return;
  980.     }
  981.  
  982.     /* We're multivol  Panic if we didn't get the right kind of response */
  983.     /* ENXIO is for the UNIX PC */
  984. #ifdef ENXIO
  985.     if(err>0 || (err<0 && errno!=ENOSPC && errno!=EIO && errno!=ENXIO))
  986. #else
  987.     if(err>0 || (err<0 && errno!=ENOSPC && errno!=EIO))
  988. #endif
  989.         writeerror(err);
  990.  
  991.     if(new_volume(0)<0)
  992.         return;
  993.     bytes_written=0;
  994.     if(f_volhdr && real_s_name[0]) {
  995.         copy_back=2;
  996.         ar_block-=2;
  997.     } else if(f_volhdr || real_s_name[0]) {
  998.         copy_back = 1;
  999.         ar_block--;
  1000.     } else
  1001.         copy_back = 0;
  1002.     if(f_volhdr) {
  1003.         bzero((void *)ar_block,RECORDSIZE);
  1004.         sprintf(ar_block->header.name,"%s Volume %d",f_volhdr,volno);
  1005.         to_oct(time(0),    1+12, ar_block->header.mtime);
  1006.         ar_block->header.linkflag = LF_VOLHDR;
  1007.         finish_header(ar_block);
  1008.     }
  1009.     if(real_s_name[0]) {
  1010.         int tmp;
  1011.  
  1012.         if(f_volhdr)
  1013.             ar_block++;
  1014.         bzero((void *)ar_block,RECORDSIZE);
  1015.         strcpy(ar_block->header.name,real_s_name);
  1016.         ar_block->header.linkflag = LF_MULTIVOL;
  1017.         to_oct((long)real_s_sizeleft,1+12,
  1018.                ar_block->header.size);
  1019.         to_oct((long)real_s_totsize-real_s_sizeleft,
  1020.                1+12,ar_block->header.offset);
  1021.         tmp=f_verbose;
  1022.         f_verbose=0;
  1023.         finish_header(ar_block);
  1024.         f_verbose=tmp;
  1025.         if(f_volhdr)
  1026.             ar_block--;
  1027.     }
  1028.  
  1029.     err = rmtwrite(archive, ar_block->charptr,(int) blocksize);
  1030.     if(err!=blocksize)
  1031.         writeerror(err);
  1032.     else if (f_totals)
  1033.             tot_written += blocksize;
  1034.             
  1035.  
  1036.     bytes_written = blocksize;
  1037.     if(copy_back) {
  1038.         ar_block+=copy_back;
  1039.         bcopy((void *)(ar_block+blocking-copy_back),
  1040.               (void *)ar_record,
  1041.               copy_back*RECORDSIZE);
  1042.         ar_record+=copy_back;
  1043.  
  1044.         if(real_s_sizeleft>=copy_back*RECORDSIZE)
  1045.             real_s_sizeleft-=copy_back*RECORDSIZE;
  1046.         else if((real_s_sizeleft+RECORDSIZE-1)/RECORDSIZE<=copy_back)
  1047.             real_s_name[0] = '\0';
  1048.         else {
  1049. #ifdef MSDOS
  1050.             if(save_name[1]==':')
  1051.                 save_name+=2;
  1052. #endif
  1053.             while(*save_name=='/')
  1054.                 save_name++;
  1055.  
  1056.             strcpy(real_s_name,save_name);
  1057.             real_s_sizeleft = save_sizeleft;
  1058.             real_s_totsize=save_totsize;
  1059.         }
  1060.         copy_back = 0;
  1061.     }
  1062. }
  1063.  
  1064. /* Handle write errors on the archive.  Write errors are always fatal */
  1065. /* Hitting the end of a volume does not cause a write error unless the write
  1066. *  was the first block of the volume */
  1067.  
  1068. void
  1069. writeerror(err)
  1070. int err;
  1071. {
  1072.     if (err < 0) {
  1073.         msg_perror("can't write to %s",ar_file);
  1074.         exit(EX_BADARCH);
  1075.     } else {
  1076.         msg("only wrote %u of %u bytes to %s",err,blocksize,ar_file);
  1077.         exit(EX_BADARCH);
  1078.     }
  1079. }
  1080.  
  1081. /*
  1082.  * Handle read errors on the archive.
  1083.  *
  1084.  * If the read should be retried, readerror() returns to the caller.
  1085.  */
  1086. void
  1087. readerror()
  1088. {
  1089. #    define    READ_ERROR_MAX    10
  1090.  
  1091.     read_error_flag++;        /* Tell callers */
  1092.  
  1093.     msg_perror("read error on %s",ar_file);
  1094.  
  1095.     if (baserec == 0) {
  1096.         /* First block of tape.  Probably stupidity error */
  1097.         exit(EX_BADARCH);
  1098.     }
  1099.  
  1100.     /*
  1101.      * Read error in mid archive.  We retry up to READ_ERROR_MAX times
  1102.      * and then give up on reading the archive.  We set read_error_flag
  1103.      * for our callers, so they can cope if they want.
  1104.      */
  1105.     if (r_error_count++ > READ_ERROR_MAX) {
  1106.         msg("Too many errors, quitting.");
  1107.         exit(EX_BADARCH);
  1108.     }
  1109.     return;
  1110. }
  1111.  
  1112.  
  1113. /*
  1114.  * Perform a read to flush the buffer.
  1115.  */
  1116. fl_read()
  1117. {
  1118.     int err;        /* Result from system call */
  1119.     int left;        /* Bytes left */
  1120.     char *more;        /* Pointer to next byte to read */
  1121.  
  1122.     /*
  1123.      * Clear the count of errors.  This only applies to a single
  1124.      * call to fl_read.  We leave read_error_flag alone; it is
  1125.      * only turned off by higher level software.
  1126.      */
  1127.     r_error_count = 0;    /* Clear error count */
  1128.  
  1129.     /*
  1130.      * If we are about to wipe out a record that
  1131.      * somebody needs to keep, copy it out to a holding
  1132.      * area and adjust somebody's pointer to it.
  1133.      */
  1134.     if (save_rec &&
  1135.         *save_rec >= ar_record &&
  1136.         *save_rec < ar_last) {
  1137.         record_save_area = **save_rec;
  1138.         *save_rec = &record_save_area;
  1139.     }
  1140.     if(write_archive_to_stdout && baserec!=0) {
  1141.         err=rmtwrite(1, ar_block->charptr, blocksize);
  1142.         if(err!=blocksize)
  1143.             writeerror(err);
  1144.     }
  1145.     if(f_multivol) {
  1146.         if(save_name) {
  1147.             if(save_name!=real_s_name) {
  1148. #ifdef MSDOS
  1149.                 if(save_name[1]==':')
  1150.                     save_name+=2;
  1151. #endif
  1152.                 while(*save_name=='/')
  1153.                     save_name++;
  1154.  
  1155.                 strcpy(real_s_name,save_name);
  1156.                 save_name=real_s_name;
  1157.             }
  1158.             real_s_totsize = save_totsize;
  1159.             real_s_sizeleft = save_sizeleft;
  1160.                 
  1161.         } else {
  1162.             real_s_name[0]='\0';
  1163.             real_s_totsize=0;
  1164.             real_s_sizeleft = 0;
  1165.         }
  1166.     }
  1167.  
  1168. error_loop:
  1169.     err = rmtread(archive, ar_block->charptr, (int)blocksize);
  1170.     if (err == blocksize)
  1171.         return;
  1172.  
  1173.     if((err == 0 || (err<0 && (errno==ENOSPC || errno == EIO))) && 
  1174.        f_multivol) {
  1175.         union record *head;
  1176.  
  1177.     try_volume:
  1178.         if(new_volume((cmd_mode==CMD_APPEND || cmd_mode==CMD_CAT || cmd_mode==CMD_UPDATE) ? 2 : 1)<0)
  1179.             return;
  1180.     vol_error:
  1181.         err = rmtread(archive, ar_block->charptr,(int) blocksize);
  1182.         if(err < 0) {
  1183.             readerror();
  1184.             goto vol_error;
  1185.         }
  1186.         if(err!=blocksize)
  1187.             goto short_read;
  1188.  
  1189.         head=ar_block;
  1190.  
  1191.         if(head->header.linkflag==LF_VOLHDR) {
  1192.             if(f_volhdr) {
  1193. #ifndef REGEX
  1194.                 char *ptr;
  1195.  
  1196.                 ptr=(char *)malloc(strlen(f_volhdr)+20);
  1197.                 sprintf(ptr,"%s Volume %d",f_volhdr,volno);
  1198. #endif
  1199. #ifdef REGEX
  1200.                 if (re_match (label_pattern, head->header.name,
  1201.                           strlen (head->header.name),
  1202.                           0, 0) < 0) {
  1203.                     msg("Volume mismatch! %s!=%s",f_volhdr,
  1204.                         head->header.name);
  1205.                     --volno;
  1206.                     goto try_volume;
  1207.                       }
  1208. #else
  1209.                  if(strcmp(ptr,head->header.name)) {
  1210.                     msg("Volume mismatch! %s!=%s",ptr,head->header.name);
  1211.                     --volno;
  1212.                     free(ptr);
  1213.                     goto try_volume;
  1214.                 }
  1215.                 free(ptr);
  1216. #endif
  1217.             }
  1218.             if(f_verbose)
  1219.                 fprintf(msg_file,"Reading %s",head->header.name);
  1220.             head++;
  1221.         } else if(f_volhdr) {
  1222.             msg("Warning:  No volume header!");
  1223.         }
  1224.  
  1225.         if(real_s_name[0]) {
  1226.             long from_oct();
  1227.  
  1228.             if(head->header.linkflag!=LF_MULTIVOL || strcmp(head->header.name,real_s_name)) {
  1229.                 msg("%s is not continued on this volume!",real_s_name);
  1230.                 --volno;
  1231.                 goto try_volume;
  1232.             }
  1233.             if(real_s_totsize!=from_oct(1+12,head->header.size)+from_oct(1+12,head->header.offset)) {
  1234.                 msg("%s is the wrong size (%ld!=%ld+%ld)",
  1235.                        head->header.name,save_totsize,
  1236.                        from_oct(1+12,head->header.size),
  1237.                        from_oct(1+12,head->header.offset));
  1238.                 --volno;
  1239.                 goto try_volume;
  1240.             }
  1241.             if(real_s_totsize-real_s_sizeleft!=from_oct(1+12,head->header.offset)) {
  1242.                 msg("This volume is out of sequence");
  1243.                 --volno;
  1244.                 goto try_volume;
  1245.             }
  1246.             head++;
  1247.         }
  1248.         ar_record=head;
  1249.         return;
  1250.     } else if (err < 0) {
  1251.         readerror();
  1252.         goto error_loop;    /* Try again */
  1253.     }
  1254.  
  1255.  short_read:
  1256.     more = ar_block->charptr + err;
  1257.     left = blocksize - err;
  1258.  
  1259. again:
  1260.     if (0 == (((unsigned)left) % RECORDSIZE)) {
  1261.         /* FIXME, for size=0, multi vol support */
  1262.         /* On the first block, warn about the problem */
  1263.         if (!f_reblock && baserec == 0 && f_verbose && err > 0) {
  1264.         /*    msg("Blocksize = %d record%s",
  1265.                 err / RECORDSIZE, (err > RECORDSIZE)? "s": "");*/
  1266.             msg("Blocksize = %d records", err / RECORDSIZE);
  1267.         }
  1268.         ar_last = ar_block + ((unsigned)(blocksize - left))/RECORDSIZE;
  1269.         return;
  1270.     }
  1271.     if (f_reblock) {
  1272.         /*
  1273.          * User warned us about this.  Fix up.
  1274.          */
  1275.         if (left > 0) {
  1276. error2loop:
  1277.             err = rmtread(archive, more, (int)left);
  1278.             if (err < 0) {
  1279.                 readerror();
  1280.                 goto error2loop;    /* Try again */
  1281.             }
  1282.             if (err == 0) {
  1283.                 msg("archive %s EOF not on block boundary",ar_file);
  1284.                 exit(EX_BADARCH);
  1285.             }
  1286.             left -= err;
  1287.             more += err;
  1288.             goto again;
  1289.         }
  1290.     } else {
  1291.         msg("only read %d bytes from archive %s",err,ar_file);
  1292.         exit(EX_BADARCH);
  1293.     }
  1294. }
  1295.  
  1296.  
  1297. /*
  1298.  * Flush the current buffer to/from the archive.
  1299.  */
  1300. flush_archive()
  1301. {
  1302.     int c;
  1303.  
  1304.     baserec += ar_last - ar_block;    /* Keep track of block #s */
  1305.     ar_record = ar_block;        /* Restore pointer to start */
  1306.     ar_last = ar_block + blocking;    /* Restore pointer to end */
  1307.  
  1308.     if (ar_reading) {
  1309.         if(time_to_start_writing) {
  1310.             time_to_start_writing=0;
  1311.             ar_reading=0;
  1312.  
  1313.             if(file_to_switch_to>=0) {
  1314.                 if((c=rmtclose(archive))<0)
  1315.                     msg_perror("Warning: can't close %s(%d,%d)",ar_file,archive,c);
  1316.  
  1317.                 archive=file_to_switch_to;
  1318.             } else
  1319.                  (void)backspace_output();
  1320.             fl_write();
  1321.         } else
  1322.             fl_read();
  1323.     } else {
  1324.         fl_write();
  1325.     }
  1326. }
  1327.  
  1328. /* Backspace the archive descriptor by one blocks worth.
  1329.    If its a tape, MTIOCTOP will work.  If its something else,
  1330.    we try to seek on it.  If we can't seek, we lose! */
  1331. backspace_output()
  1332. {
  1333.     long cur;
  1334.     /* int er; */
  1335.     extern char *output_start;
  1336.  
  1337. #ifdef MTIOCTOP
  1338.     struct mtop t;
  1339.  
  1340.     t.mt_op = MTBSR;
  1341.     t.mt_count = 1;
  1342.     if((rmtioctl(archive,MTIOCTOP,&t))>=0)
  1343.         return 1;
  1344.     if(errno==EIO && (rmtioctl(archive,MTIOCTOP,&t))>=0)
  1345.         return 1;
  1346. #endif
  1347.  
  1348.         cur=rmtlseek(archive,0L,1);
  1349.     cur-=blocksize;
  1350.     /* Seek back to the beginning of this block and
  1351.        start writing there. */
  1352.  
  1353.     if(rmtlseek(archive,cur,0)!=cur) {
  1354.         /* Lseek failed.  Try a different method */
  1355.         msg("Couldn't backspace archive file.  It may be unreadable without -i.");
  1356.         /* Replace the first part of the block with nulls */
  1357.         if(ar_block->charptr!=output_start)
  1358.             bzero(ar_block->charptr,output_start-ar_block->charptr);
  1359.         return 2;
  1360.     }
  1361.     return 3;
  1362. }
  1363.  
  1364.  
  1365. /*
  1366.  * Close the archive file.
  1367.  */
  1368. close_archive()
  1369. {
  1370.     int child;
  1371.     int status;
  1372.     int c;
  1373.  
  1374.     if (time_to_start_writing || !ar_reading)
  1375.         flush_archive();
  1376.     if(cmd_mode==CMD_DELETE) {
  1377.         long pos;
  1378.  
  1379.         pos = rmtlseek(archive,0L,1);
  1380. #ifndef MSDOS
  1381.         /* FIXME does ftruncate really take an INT?! */
  1382.         (void) ftruncate(archive,(int)pos);
  1383. #else
  1384.         (void)rmtwrite(archive,"",0);
  1385. #endif
  1386.     }
  1387.     if(f_verify)
  1388.         verify_volume();
  1389.  
  1390.     if((c=rmtclose(archive))<0)
  1391.         msg_perror("Warning: can't close %s(%d,%d)",ar_file,archive,c);
  1392.  
  1393.     if (childpid)
  1394.         child_close();
  1395.  
  1396. #ifdef HOST
  1397. !!!!    if (f_host) {
  1398.         if (!ar_reading)
  1399.             host_send(ar_file);
  1400.         host_end();
  1401.     }
  1402. #endif
  1403. }
  1404.  
  1405.  
  1406. #ifdef DONTDEF
  1407. /*
  1408.  * Message management.
  1409.  *
  1410.  * anno writes a message prefix on stream (eg stdout, stderr).
  1411.  *
  1412.  * The specified prefix is normally output followed by a colon and a space.
  1413.  * However, if other command line options are set, more output can come
  1414.  * out, such as the record # within the archive.
  1415.  *
  1416.  * If the specified prefix is NULL, no output is produced unless the
  1417.  * command line option(s) are set.
  1418.  *
  1419.  * If the third argument is 1, the "saved" record # is used; if 0, the
  1420.  * "current" record # is used.
  1421.  */
  1422. void
  1423. anno(stream, prefix, savedp)
  1424.     FILE    *stream;
  1425.     char    *prefix;
  1426.     int    savedp;
  1427. {
  1428. #    define    MAXANNO    50
  1429.     char    buffer[MAXANNO];    /* Holds annorecment */
  1430. #    define    ANNOWIDTH 13
  1431.     int    space;
  1432.     long    offset;
  1433.     int    save_e;
  1434.  
  1435.     save_e=errno;
  1436.     /* Make sure previous output gets out in sequence */
  1437.     if (stream == stderr)
  1438.         fflush(stdout);
  1439.     if (f_sayblock) {
  1440.         if (prefix) {
  1441.             fputs(prefix, stream);
  1442.             putc(' ', stream);
  1443.         }
  1444.         offset = ar_record - ar_block;
  1445.         (void) sprintf(buffer, "rec %d: ",
  1446.             savedp?    saved_recno:
  1447.                 baserec + offset);
  1448.         fputs(buffer, stream);
  1449.         space = ANNOWIDTH - strlen(buffer);
  1450.         if (space > 0) {
  1451.             fprintf(stream, "%*s", space, "");
  1452.         }
  1453.     } else if (prefix) {
  1454.         fputs(prefix, stream);
  1455.         fputs(": ", stream);
  1456.     }
  1457.     errno=save_e;
  1458. }
  1459. #endif
  1460.  
  1461. /* We've hit the end of the old volume.  Close it and open the next one */
  1462. /* Values for type:  0: writing  1: reading  2: updating */
  1463. new_volume(type)
  1464. int    type;
  1465. {
  1466.     int    c;
  1467.     char    inbuf[80];
  1468.     char    *p;
  1469.     static FILE *read_file = 0;
  1470.     extern int now_verifying;
  1471.     extern char TTY_NAME[];
  1472. #ifndef ANSI
  1473.     char *getenv();
  1474. #endif
  1475.  
  1476.     if(!read_file && !f_run_script_at_end)
  1477.         read_file = (archive==0) ? fopen(TTY_NAME, "r") : stdin;
  1478.  
  1479.     if(now_verifying)
  1480.         return -1;
  1481.     if(f_verify)
  1482.         verify_volume();
  1483.     if((c=rmtclose(archive))<0)
  1484.         msg_perror("Warning: can't close %s(%d,%d)",ar_file,archive,c);
  1485.  
  1486.     if (childpid)
  1487.         child_close();
  1488. #ifdef HOST
  1489.     if (f_host && type==0)
  1490.         host_send(ar_file);
  1491. #endif
  1492.     volno++;
  1493.  tryagain:
  1494.     if (f_run_script_at_end)
  1495.         system(info_script);
  1496.     else for(;;) {
  1497.         fprintf(msg_file,"\007Prepare volume #%d and hit return: ",volno);
  1498.         fflush(msg_file);
  1499. #ifdef __EMX__
  1500.                 while (_read_kbd(0, 0, 0) != -1);
  1501.         /* not available with -Zomf -Zsys in 0.8e, but in 0.8f */
  1502. #endif
  1503.         if(fgets(inbuf,sizeof(inbuf),read_file)==0) {
  1504.              fprintf(msg_file,"EOF?  What does that mean?");
  1505.             if(cmd_mode!=CMD_EXTRACT && cmd_mode!=CMD_LIST && cmd_mode!=CMD_DIFF)
  1506.                 msg("Warning:  Archive is INCOMPLETE!");
  1507.             exit(EX_BADARCH);
  1508.         }
  1509.         if(inbuf[0]=='\n' || inbuf[0]=='y' || inbuf[0]=='Y')
  1510.             break;
  1511.  
  1512.         switch(inbuf[0]) {
  1513.         case '?':
  1514.         {
  1515.             fprintf(msg_file,"\
  1516.  n [name]   Give a new filename for the next (and subsequent) volume(s)\n\
  1517.  q          Abort tar\n\
  1518.  !          Spawn a subshell\n\
  1519.  ?          Print this list\n");
  1520.         }
  1521.             break;
  1522.  
  1523.         case 'q':    /* Quit */
  1524.             fprintf(msg_file,"No new volume; exiting.\n");
  1525.             if(cmd_mode!=CMD_EXTRACT && cmd_mode!=CMD_LIST && cmd_mode!=CMD_DIFF)
  1526.                 msg("Warning:  Archive is INCOMPLETE!");
  1527.             exit(EX_BADARCH);
  1528.  
  1529.         case 'n':    /* Get new file name */
  1530.         {
  1531.             char *q,*r;
  1532.             static char *old_name;
  1533.  
  1534.             for(q= &inbuf[1];*q==' ' || *q=='\t';q++)
  1535.                 ;
  1536.             for(r=q;*r;r++)
  1537.                 if(*r=='\n')
  1538.                     *r='\0';
  1539.             if(old_name)
  1540.                 free(old_name);
  1541.             old_name=p=(char *)malloc((unsigned)(strlen(q)+2));
  1542.             if(p==0) {
  1543.                 msg("Can't allocate memory for name");
  1544.                 exit(EX_SYSTEM);
  1545.             }
  1546.             (void) strcpy(p,q);
  1547.             ar_file=p;
  1548.         }
  1549.             break;
  1550.  
  1551.         case '!':
  1552. #ifdef MSDOS
  1553.             spawnl(P_WAIT,getenv("COMSPEC"),"-",0);
  1554. #else
  1555.                 /* JF this needs work! */
  1556.             switch(fork()) {
  1557.             case -1:
  1558.                 msg_perror("can't fork!");
  1559.                 break;
  1560.             case 0:
  1561.                 p=getenv("SHELL");
  1562.                 if(p==0) p="/bin/sh";
  1563.                 execlp(p,"-sh","-i",0);
  1564.                 msg_perror("can't exec a shell %s",p);
  1565.                 _exit(55);
  1566.             default:
  1567.                 wait(0);
  1568.                 break;
  1569.             }
  1570. #endif
  1571.             break;
  1572.         }
  1573.     }
  1574.  
  1575. #ifdef HOST
  1576.     if (f_host && type!=0)
  1577.         host_recv(ar_file);
  1578. #endif
  1579.     if(f_compress)
  1580.         child_open();
  1581.     else if(type==2 || f_verify)
  1582.         archive=rmtopen(ar_file,O_RDWR|O_CREAT|O_BINARY,0666);
  1583.     else if(type==1)
  1584.         archive=rmtopen(ar_file,O_RDONLY|O_BINARY,0666);
  1585.     else if(type==0)
  1586.         archive=rmtcreat(ar_file,0666);
  1587.     else
  1588.         archive= -1;
  1589.  
  1590.     if(archive<0) {
  1591.         msg_perror("can't open %s",ar_file);
  1592.         goto tryagain;
  1593.     }
  1594. #ifdef MSDOS
  1595.     setmode(archive,O_BINARY);
  1596. #endif
  1597.     return 0;
  1598. }
  1599.  
  1600. /* this is a useless function that takes a buffer returned by wantbytes
  1601.    and does nothing with it.  If the function called by wantbytes returns
  1602.    an error indicator (non-zero), this function is called for the rest of
  1603.    the file.
  1604.  */
  1605. int
  1606. no_op(size,data)
  1607. int size;
  1608. char *data;
  1609. {
  1610.     return 0;
  1611. }
  1612.  
  1613. /* Some other routine wants SIZE bytes in the archive.  For each chunk of
  1614.    the archive, call FUNC with the size of the chunk, and the address of
  1615.    the chunk it can work with.
  1616.  */
  1617. int
  1618. wantbytes(size,func)
  1619. long size;
  1620. int (*func)();
  1621. {
  1622.     char *data;
  1623.     long    data_size;
  1624.  
  1625.     while(size) {
  1626.         data = findrec()->charptr;
  1627.         if (data == NULL) {    /* Check it... */
  1628.             msg("Unexpected EOF on archive file");
  1629.             return -1;
  1630.         }
  1631.         data_size = endofrecs()->charptr - data;
  1632.         if(data_size>size)
  1633.             data_size=size;
  1634.         if((*func)(data_size,data))
  1635.             func=no_op;
  1636.         userec((union record *)(data + data_size - 1));
  1637.         size-=data_size;
  1638.     }
  1639.     return 0;
  1640. }
  1641.