Arc v5.21 (3 of 6)
egray at fthood.UUCP
egray at fthood.UUCP
Mon Jan 2 05:39:00 AEST 1989
This is part 3 (of 6) to the Arc v5.21 distribution package.
Emmet P. Gray US Army, HQ III Corps & Fort Hood
...!uunet!uiucuxc!fthood!egray Attn: AFZF-DE-ENV
Directorate of Engineering & Housing
Environmental Management Office
Fort Hood, TX 76544-5057
------------------------------------------------------------------------------
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
# arcadd.c
# arccode.c
# arccvt.c
# arcdata.c
# arcdel.c
# arcdos.c
# arcext.c
# arcio.c
# arclst.c
# This archive created: Sun Jan 1 12:48:17 1989
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'arcadd.c'" '(12955 characters)'
if test -f 'arcadd.c'
then
echo shar: "will not over-write existing file 'arcadd.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcadd.c'
X/*
X * $Header: arcadd.c,v 1.10 88/11/16 17:43:25 hyc Exp $
X */
X
X/*
X * ARC - Archive utility - ARCADD
X *
X * Version 3.40, created on 06/18/86 at 13:10:18
X *
X * (C) COPYRIGHT 1985,86 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains the routines used to add files to an archive.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X#if MTS
X#include <mts.h>
X#endif
X
Xstatic int addfile();
Xchar *strcpy();
Xint strcmp(), strlen(), free(), readhdr(), unlink();
X#if UNIX
Xint izadir();
X#endif
Xvoid writehdr(), filecopy(), getstamp();
Xvoid pack(), closearc(), openarc(), abort();
X
Xvoid
Xaddarc(num, arg, move, update, fresh) /* add files to archive */
X int num; /* number of arguments */
X char *arg[]; /* pointers to arguments */
Xint move; /* true if moving file */
Xint update; /* true if updating */
Xint fresh; /* true if freshening */
X{
X char *d, *dir(); /* directory junk */
X char buf[STRLEN]; /* pathname buffer */
X char **path; /* pointer to pointers to paths */
X char **name; /* pointer to pointers to names */
X int nfiles = 0; /* number of files in lists */
X int notemp; /* true until a template works */
X int nowork = 1; /* true until files are added */
X char *i, *rindex(); /* string indexing junk */
X char *malloc(), *realloc(); /* memory allocators */
X int n; /* index */
X#ifdef LOCAL
X extern int unix_names;
X#endif /* LOCAL */
X#if MSDOS
X unsigned int coreleft(); /* remaining memory reporter */
X#endif
X int addbunch();
X
X if (num < 1) { /* if no files named */
X num = 1; /* then fake one */
X#if DOS
X arg[0] = "*.*"; /* add everything */
X#endif
X#if UNIX
X arg[0] = "*";
X#endif
X#if MTS
X arg[0] = "?";
X#endif
X }
X path = (char **) malloc(sizeof(char **));
X name = (char **) malloc(sizeof(char **));
X
X
X for (n = 0; n < num; n++) { /* for each template supplied */
X strcpy(buf, arg[n]); /* get ready to fix path */
X#if !MTS
X if (!(i = rindex(buf, '\\')))
X if (!(i = rindex(buf, '/')))
X if (!(i = rindex(buf, ':')))
X i = buf - 1;
X#else
X if (!(i = rindex(buf, sepchr[0])))
X if (buf[0] != tmpchr[0])
X i = buf - 1;
X else
X i = buf;
X#endif
X i++; /* pointer to where name goes */
X
X notemp = 1; /* reset files flag */
X for (d = dir(arg[n]); d; d = dir(NULL)) {
X notemp = 0; /* template is giving results */
X nfiles++; /* add each matching file */
X path = (char **) realloc(path, nfiles * sizeof(char **));
X name = (char **) realloc(name, nfiles * sizeof(char **));
X strcpy(i, d); /* put name in path */
X path[nfiles - 1] = malloc(strlen(buf) + 1);
X strcpy(path[nfiles - 1], buf);
X name[nfiles - 1] = d; /* save name */
X#if LOCAL
X /* make it a MSDOS file name */
X if (!unix_names) {
X if (legalize(path[nfiles-1], name[nfiles-1])) {
X nfiles--;
X continue;
X }
X }
X#endif /* LOCAL */
X#if MSDOS
X if (coreleft() < 5120) {
X nfiles = addbunch(nfiles, path, name, move, update, fresh);
X nowork = nowork && !nfiles;
X while (nfiles) {
X free(path[--nfiles]);
X free(name[nfiles]);
X }
X free(path);
X free(name);
X path = name = NULL;
X }
X#endif
X }
X if (notemp && warn)
X printf("No files match: %s\n", arg[n]);
X }
X
X if (nfiles) {
X nfiles = addbunch(nfiles, path, name, move, update, fresh);
X nowork = nowork && !nfiles;
X while (nfiles) {
X free(path[--nfiles]);
X free(name[nfiles]);
X }
X free(path);
X free(name);
X }
X if (nowork && warn)
X printf("No files were added.\n");
X}
X
Xint
Xaddbunch(nfiles, path, name, move, update, fresh) /* add a bunch of files */
X int nfiles; /* number of files to add */
X char **path; /* pointers to pathnames */
X char **name; /* pointers to filenames */
X int move; /* true if moving file */
X int update; /* true if updating */
X int fresh; /* true if freshening */
X{
X int m, n; /* indices */
X char *d; /* swap pointer */
X struct heads hdr; /* file header data storage */
X
X for (n = 0; n < nfiles - 1; n++) { /* sort the list of names */
X for (m = n + 1; m < nfiles; m++) {
X if (strcmp(name[n], name[m]) > 0) {
X d = path[n];
X path[n] = path[m];
X path[m] = d;
X d = name[n];
X name[n] = name[m];
X name[m] = d;
X }
X }
X }
X
X for (n = 0; n < nfiles - 1;) { /* consolidate the list of names */
X if (!strcmp(path[n], path[n + 1]) /* if duplicate names */
X ||!strcmp(path[n], arcname) /* or this archive */
X#if UNIX
X ||izadir(path[n]) /* or a directory */
X#endif
X ||!strcmp(path[n], newname) /* or the new version */
X ||!strcmp(path[n], bakname)) { /* or its backup */
X free(path[n]); /* then forget the file */
X free(name[n]);
X for (m = n; m < nfiles - 1; m++) {
X path[m] = path[m + 1];
X name[m] = name[m + 1];
X }
X nfiles--;
X } else
X n++; /* else test the next one */
X }
X
X if (!strcmp(path[n], arcname) /* special check for last file */
X ||!strcmp(path[n], newname) /* courtesy of Rick Moore */
X#if UNIX
X ||izadir(path[n])
X#endif
X || !strcmp(path[n], bakname)) {
X free(path[n]);
X free(name[n]);
X nfiles--;
X }
X if (!nfiles) /* make sure we got some */
X return 0;
X
X for (n = 0; n < nfiles - 1; n++) { /* watch out for duplicate
X * names */
X#ifdef LOCAL
X if (!strcmp(name[n], name[n + 1])) {
X printf("Duplicate filenames: %s %s\n", path[n], path[n+1]);
X printf("Skipping filename: %s\n", path[n+1]);
X free(path[n+1]);
X free(name[n+1]);
X for (m = n+1; m < nfiles-1 ; m++) {
X path[m] = path[m+1];
X name[m] = name[m+1];
X }
X nfiles--;
X }
X#else /* LOCAL */
X if (!strcmp(name[n], name[n + 1]))
X abort("Duplicate filenames:\n %s\n %s", path[n], path[n + 1]);
X#endif /* LOCAL */
X }
X openarc(1); /* open archive for changes */
X
X for (n = 0; n < nfiles;) { /* add each file in the list */
X if (addfile(path[n], name[n], update, fresh) < 0) {
X free(path[n]); /* remove this name if */
X free(name[n]); /* it wasn't added */
X for (m = n; m < nfiles-1 ; m++) {
X path[m] = path[m+1];
X name[m] = name[m+1];
X }
X nfiles--;
X } else n++;
X }
X
X /* now we must copy over all files that follow our additions */
X
X while (readhdr(&hdr, arc)) { /* while more entries to copy */
X writehdr(&hdr, new);
X filecopy(arc, new, hdr.size);
X }
X hdrver = 0; /* archive EOF type */
X writehdr(&hdr, new); /* write out our end marker */
X closearc(1); /* close archive after changes */
X
X if (move) { /* if this was a move */
X for (n = 0; n < nfiles; n++) { /* then delete each file
X * added */
X if (unlink(path[n]) && warn) {
X printf("Cannot unsave %s\n", path[n]);
X nerrs++;
X }
X }
X }
X return nfiles; /* say how many were added */
X}
X
Xstatic int
Xaddfile(path, name, update, fresh) /* add named file to archive */
X char *path; /* path name of file to add */
X char *name; /* name of file to add */
X int update; /* true if updating */
X int fresh; /* true if freshening */
X{
X struct heads nhdr; /* data regarding the new file */
X struct heads ohdr; /* data regarding an old file */
X FILE *f, *fopen(); /* file to add, opener */
X long starts, ftell(); /* file locations */
X int upd = 0;/* true if replacing an entry */
X#ifdef LOCAL
X void upper();
X#endif /* LOCAL */
X
X#if !MTS
X if (!(f = fopen(path, OPEN_R)))
X#else
X if (image)
X f = fopen(path, "rb");
X else
X f = fopen(path, "r");
X if (!f)
X#endif
X {
X if (warn) {
X printf("Cannot read file: %s\n", path);
X nerrs++;
X }
X return(-1);
X }
X#if !DOS
X if (strlen(name) >= FNLEN) {
X if (warn) {
X char buf[STRLEN];
X printf("WARNING: File %s name too long!\n", name);
X name[FNLEN-1]='\0';
X while(1) {
X printf(" Truncate to %s (y/n)? ", name);
X fflush(stdout);
X fgets(buf, STRLEN, stdin);
X *buf = toupper(*buf);
X if (*buf == 'Y' || *buf == 'N')
X break;
X }
X if (*buf == 'N') {
X printf("Skipping...\n");
X fclose(f);
X return(-1);
X }
X }
X else {
X if (note)
X printf("Skipping file: %s - name too long.\n",
X name);
X fclose(f);
X return(-1);
X }
X }
X#endif
X#ifdef LOCAL
X upper(name);
X#endif /* LCOAL */
X strcpy(nhdr.name, name);/* save name */
X nhdr.size = 0; /* clear out size storage */
X nhdr.crc = 0; /* clear out CRC check storage */
X#if !MTS
X getstamp(f, &nhdr.date, &nhdr.time);
X#else
X {
X char *buffer, *malloc();
X int inlen;
X struct GDDSECT *region;
X
X region=gdinfo(f->_fd._fdub);
X inlen=region->GDINLEN;
X buffer=malloc(inlen); /* maximum line length */
X setbuf(f,buffer);
X f->_bufsiz=inlen;
X f->_mods|=_NOIC; /* Don't do "$continue with" */
X f->_mods&=~_IC; /* turn it off, if set... */
X }
X getstamp(path, &nhdr.date, &nhdr.time);
X#endif
X
X /* position archive to spot for new file */
X
X if (arc) { /* if adding to existing archive */
X starts = ftell(arc); /* where are we? */
X while (readhdr(&ohdr, arc)) { /* while more files to check */
X if (!strcmp(ohdr.name, nhdr.name)) {
X upd = 1; /* replace existing entry */
X if (update || fresh) { /* if updating or
X * freshening */
X if (nhdr.date < ohdr.date
X || (nhdr.date == ohdr.date && nhdr.time <= ohdr.time)) {
X fseek(arc, starts, 0);
X fclose(f);
X return(0);/* skip if !newer */
X }
X }
X }
X if (strcmp(ohdr.name, nhdr.name) >= 0)
X break; /* found our spot */
X
X writehdr(&ohdr, new); /* entry preceeds update;
X * keep it */
X filecopy(arc, new, ohdr.size);
X starts = ftell(arc); /* now where are we? */
X }
X
X if (upd) { /* if an update */
X if (note) {
X printf("Updating file: %-12s ", name);
X fflush(stdout);
X }
X fseek(arc, ohdr.size, 1);
X } else if (fresh) { /* else if freshening */
X fseek(arc, starts, 0); /* then do not add files */
X fclose(f);
X return(0);
X } else { /* else adding a new file */
X if (note) {
X printf("Adding file: %-12s ", name);
X fflush(stdout);
X }
X fseek(arc, starts, 0); /* reset for next time */
X }
X } else { /* no existing archive */
X if (fresh) { /* cannot freshen nothing */
X fclose(f);
X return(0);
X } else if (note) { /* else adding a file */
X printf("Adding file: %-12s ", name);
X fflush(stdout);
X }
X }
X
X starts = ftell(new); /* note where header goes */
X hdrver = ARCVER; /* anything but end marker */
X writehdr(&nhdr, new); /* write out header skeleton */
X pack(f, new, &nhdr); /* pack file into archive */
X fseek(new, starts, 0); /* move back to header skeleton */
X writehdr(&nhdr, new); /* write out real header */
X fseek(new, nhdr.size, 1); /* skip over data to next header */
X fclose(f); /* all done with the file */
X return(0);
X}
X
X#ifdef LOCAL
X/*
X * Convert a Unix filename to a legal MSDOS name. Returns a 1 if the file
X * can't be found (or is not a regular file). Will truncate file and
X * extension names, will substitute the letter 'X' for any illegal character
X * in the name.
X */
X
X#include <ctype.h>
X#include <sys/types.h>
X#include <sys/stat.h>
X
Xint
Xlegalize(path, name)
Xchar *path, *name;
X{
X static char *dev[8] = {"CON", "AUX", "COM1", "LPT1", "PRN", "LPT2",
X "LPT3", "NUL"};
X char *s, *temp, *ext, *strcpy(), *strpbrk(), buf[256];
X int i, dot, modified, verbose;
X struct stat stbuf;
X
X/* verbose = warn; */
X verbose = 0;
X
X if (stat(path, &stbuf) < 0) {
X fprintf(stderr, "Can't find \"%s\"\n", path);
X return(1);
X }
X if ((stbuf.st_mode & S_IFREG) != S_IFREG) {
X if (verbose)
X fprintf(stderr, "\"%s\" Is not a regular file\n", path);
X return(1);
X }
X
X strcpy(buf, name);
X temp = buf;
X
X ext = "";
X dot = 0;
X for (s = temp; *s; ++s) {
X if (*s == '.' && !dot) {
X dot = 1;
X *s = '\0';
X ext = s + 1;
X }
X if (islower(*s))
X *s = toupper(*s);
X }
X if (*temp == '\0') {
X temp = "X";
X if (verbose)
X printf("\"%s\" Null name component, using \"%s.%s\"\n", name, temp, ext);
X }
X for (i=0; i<8; i++) {
X if (!strcmp(temp, dev[i])) {
X *temp = 'X';
X if (verbose)
X printf("\"%s\" Is a device name, using \"%s.%s\"\n", name, temp, ext);
X }
X }
X if (strlen(temp) > 8) {
X *(temp+8) = '\0';
X if (verbose)
X printf("\"%s\" Name too long, using, \"%s.%s\"\n", name, temp, ext);
X }
X if (strlen(ext) > 3) {
X *(ext+3) = '\0';
X if (verbose)
X printf("\"%s\" Extension too long, using \"%s.%s\"\n", name, temp, ext);
X }
X modified = 0;
X while (s = strpbrk(temp, "^+=/[]:',?*\\<>|\". ")) {
X modified++;
X *s = 'X';
X }
X while (s = strpbrk(ext, "^+=/[]:',?*\\<>|\". ")) {
X modified++;
X *s = 'X';
X }
X if (modified && verbose)
X printf("\"%s\" Contains illegal character(s), using \"%s.%s\"\n", name, temp, ext);
X
X if (*ext != '\0')
X sprintf(name, "%s.%s", temp, ext);
X else
X strcpy(name, temp);
X return(0);
X}
X
X#ifdef BSD
X
Xchar *
Xstrpbrk(p1, p2)
Xchar *p1, *p2;
X{
X char *p2start = p2;
X
X while (*p1) {
X while (*p2) {
X if (*p2 == *p1)
X return p1;
X p2++;
X }
X p2 = p2start;
X p1++;
X }
X return NULL;
X}
X
X#endif /* BSD */
X#endif /* LOCAL */
SHAR_EOF
if test 12955 -ne "`wc -c < 'arcadd.c'`"
then
echo shar: "error transmitting 'arcadd.c'" '(should have been 12955 characters)'
fi
fi
echo shar: "extracting 'arccode.c'" '(1192 characters)'
if test -f 'arccode.c'
then
echo shar: "will not over-write existing file 'arccode.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arccode.c'
X/*
X * $Header: arccode.c,v 1.1 88/06/01 15:15:58 hyc Locked $
X */
X
X/*
X * ARC - Archive utility - ARCCODE
X *
X * Version 1.02, created on 01/20/86 at 13:33:35
X *
X * (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains the routines used to encrypt and decrypt data
X * in an archive. The encryption method is nothing fancy, being just a
X * routine XOR, but it is used on the packed data, and uses a variable length
X * key. The end result is something that is in theory crackable, but I'd
X * hate to try it. It should be more than sufficient for casual use.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X
Xstatic char *p; /* password pointer */
X
Xvoid
Xsetcode()
X{ /* get set for encoding/decoding */
X p = password; /* reset password pointer */
X}
X
Xint
Xcode(c) /* encode some character */
Xint c; /* character to encode */
X{
X if (p) { /* if password is in use */
X if (!*p) /* if we reached the end */
X p = password; /* then wrap back to the start */
X return c ^ *p++;/* very simple here */
X } else
X return c; /* else no encryption */
X}
SHAR_EOF
if test 1192 -ne "`wc -c < 'arccode.c'`"
then
echo shar: "error transmitting 'arccode.c'" '(should have been 1192 characters)'
fi
fi
echo shar: "extracting 'arccvt.c'" '(3396 characters)'
if test -f 'arccvt.c'
then
echo shar: "will not over-write existing file 'arccvt.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arccvt.c'
X/*
X * $Header: arccvt.c,v 1.5 88/06/01 19:17:40 hyc Locked $
X */
X
X/*
X * ARC - Archive utility - ARCCVT
X *
X * Version 1.16, created on 02/03/86 at 22:53:02
X *
X * (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains the routines used to convert archives to use
X * newer file storage methods.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X
Xvoid openarc(), rempath(), closearc(), abort(), pack(), writehdr(), filecopy();
Xint match(), readhdr(), unpack(), unlink();
X
Xstatic char tempname[STRLEN]; /* temp file name */
X
Xvoid
Xcvtarc(num, arg) /* convert archive */
X int num; /* number of arguments */
X char *arg[]; /* pointers to arguments */
X{
X struct heads hdr; /* file header */
X int cvt; /* true to convert current file */
X int did[MAXARG];/* true when argument was used */
X int n; /* index */
X char *makefnam(); /* filename fixer */
X FILE *fopen();/* file opener */
X void cvtfile();
X
X if (arctemp) /* use temp area if specified */
X sprintf(tempname, "%s.CVT", arctemp);
X else
X makefnam("$ARCTEMP.CVT", arcname, tempname);
X#if !DOS
X image = 1;
X#endif
X
X openarc(1); /* open archive for changes */
X
X for (n = 0; n < num; n++) /* for each argument */
X did[n] = 0; /* reset usage flag */
X rempath(num, arg); /* strip off paths */
X
X if (num) { /* if files were named */
X while (readhdr(&hdr, arc)) { /* while more files to check */
X cvt = 0;/* reset convert flag */
X for (n = 0; n < num; n++) { /* for each template
X * given */
X if (match(hdr.name, arg[n])) {
X cvt = 1; /* turn on convert flag */
X did[n] = 1; /* turn on usage flag */
X break; /* stop looking */
X }
X }
X
X if (cvt)/* if converting this one */
X cvtfile(&hdr); /* then do it */
X else { /* else just copy it */
X writehdr(&hdr, new);
X filecopy(arc, new, hdr.size);
X }
X }
X } else
X while (readhdr(&hdr, arc)) /* else convert all files */
X cvtfile(&hdr);
X
X hdrver = 0; /* archive EOF type */
X writehdr(&hdr, new); /* write out our end marker */
X closearc(1); /* close archive after changes */
X
X if (note) {
X for (n = 0; n < num; n++) { /* report unused args */
X if (!did[n]) {
X printf("File not found: %s\n", arg[n]);
X nerrs++;
X }
X }
X }
X}
X
Xvoid
Xcvtfile(hdr) /* convert a file */
X struct heads *hdr; /* pointer to header data */
X{
X long starts, ftell(); /* where the file goes */
X FILE *tmp, *fopen(); /* temporary file */
X
X if (!(tmp = fopen(tempname, "w+b")))
X abort("Unable to create temporary file %s", tempname);
X
X if (note) {
X printf("Converting file: %-12s reading, ", hdr->name);
X fflush(stdout);
X }
X unpack(arc, tmp, hdr); /* unpack the entry */
X fseek(tmp, 0L, 0); /* reset temp for reading */
X
X starts = ftell(new); /* note where header goes */
X hdrver = ARCVER; /* anything but end marker */
X writehdr(hdr, new); /* write out header skeleton */
X pack(tmp, new, hdr); /* pack file into archive */
X fseek(new, starts, 0); /* move back to header skeleton */
X writehdr(hdr, new); /* write out real header */
X fseek(new, hdr->size, 1); /* skip over data to next header */
X fclose(tmp); /* all done with the file */
X if (unlink(tempname) && warn) {
X printf("Cannot unsave %s\n", tempname);
X nerrs++;
X }
X}
SHAR_EOF
if test 3396 -ne "`wc -c < 'arccvt.c'`"
then
echo shar: "error transmitting 'arccvt.c'" '(should have been 3396 characters)'
fi
fi
echo shar: "extracting 'arcdata.c'" '(2067 characters)'
if test -f 'arcdata.c'
then
echo shar: "will not over-write existing file 'arcdata.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcdata.c'
X/*
X * $Header: arcdata.c,v 1.7 88/07/31 18:47:22 hyc Exp $
X */
X
X/* ARC - Archive utility - ARCDATA
X
X Version 2.17, created on 04/22/87 at 13:09:43
X
X(C) COPYRIGHT 1985,86 by System Enhancement Associates; ALL RIGHTS RESERVED
X
X By: Thom Henderson
X
X Description:
X This file defines the external data storage used by the ARC
X archive utility.
X
X
X Language:
X Computer Innovations Optimizing C86
X*/
X#include <stdio.h>
X
X#define DONT_DEFINE
X#include "arc.h"
X
Xint keepbak = 0; /* true if saving the old archive */
X#if UNIX
Xint image = 1; /* true to suppress CRLF/LF x-late */
X#endif
X#if MTS
Xint image = 0; /* true to suppress EBCDIC/ASCII x-late */
Xchar sepchr[2] = ":";/* Shared file separator */
Xchar tmpchr[2] = "-";/* Temporary file prefix */
X#endif
X#if GEMDOS
Xint hold = 0; /* true to pause before exit */
X#endif
Xint warn = 1; /* true to print warnings */
Xint note = 1; /* true to print comments */
Xint bose = 0; /* true to be verbose */
Xint nocomp = 0; /* true to suppress compression */
Xint overlay = 0; /* true to overlay on extract */
Xint kludge = 0; /* kludge flag */
Xchar *arctemp = NULL; /* arc temp file prefix */
Xchar *password = NULL;/* encryption password pointer */
Xint nerrs = 0; /* number of errors encountered */
Xint changing = 0; /* true if archive being modified */
X
Xchar hdrver; /* header version */
X
XFILE *arc; /* the old archive */
XFILE *new; /* the new archive */
Xchar arcname[STRLEN]; /* storage for archive name */
Xchar bakname[STRLEN]; /* storage for backup copy name */
Xchar newname[STRLEN]; /* storage for new archive name */
Xunsigned short arcdate = 0; /* archive date stamp */
Xunsigned short arctime = 0; /* archive time stamp */
Xunsigned short olddate = 0; /* old archive date stamp */
Xunsigned short oldtime = 0; /* old archive time stamp */
Xint dosquash = 0; /* true to squash instead of crunch */
SHAR_EOF
if test 2067 -ne "`wc -c < 'arcdata.c'`"
then
echo shar: "error transmitting 'arcdata.c'" '(should have been 2067 characters)'
fi
fi
echo shar: "extracting 'arcdel.c'" '(2055 characters)'
if test -f 'arcdel.c'
then
echo shar: "will not over-write existing file 'arcdel.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcdel.c'
X/*
X * $Header: arcdel.c,v 1.3 88/04/19 01:39:32 hyc Exp $
X */
X
X/*
X * ARC - Archive utility - ARCDEL
X *
X * Version 2.09, created on 02/03/86 at 22:53:27
X *
X * (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains the routines used to delete entries in an
X * archive.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X
Xvoid abort(), rempath(), openarc(), closearc(), writehdr(), filecopy();
Xint match(), readhdr();
X
Xvoid
Xdelarc(num, arg) /* remove files from archive */
X int num; /* number of arguments */
X char *arg[]; /* pointers to arguments */
X{
X struct heads hdr; /* header data */
X int del; /* true to delete a file */
X int did[MAXARG];/* true when argument used */
X int n; /* index */
X
X if (!num) /* she must specify which */
X abort("You must tell me which files to delete!");
X
X for (n = 0; n < num; n++) /* for each argument */
X did[n] = 0; /* reset usage flag */
X rempath(num, arg); /* strip off paths */
X
X openarc(1); /* open archive for changes */
X
X while (readhdr(&hdr, arc)) { /* while more entries in archive */
X del = 0; /* reset delete flag */
X for (n = 0; n < num; n++) { /* for each template given */
X if (match(hdr.name, arg[n])) {
X del = 1; /* turn on delete flag */
X did[n] = 1; /* turn on usage flag */
X break; /* stop looking */
X }
X }
X
X if (del) { /* skip over unwanted files */
X fseek(arc, hdr.size, 1);
X if (note)
X printf("Deleting file: %s\n", hdr.name);
X } else { /* else copy over file data */
X writehdr(&hdr, new); /* write out header and file */
X filecopy(arc, new, hdr.size);
X }
X }
X
X hdrver = 0; /* special end of archive type */
X writehdr(&hdr, new); /* write out archive end marker */
X closearc(1); /* close archive after changes */
X
X if (note) {
X for (n = 0; n < num; n++) { /* report unused arguments */
X if (!did[n]) {
X printf("File not found: %s\n", arg[n]);
X nerrs++;
X }
X }
X }
X}
SHAR_EOF
if test 2055 -ne "`wc -c < 'arcdel.c'`"
then
echo shar: "error transmitting 'arcdel.c'" '(should have been 2055 characters)'
fi
fi
echo shar: "extracting 'arcdos.c'" '(4684 characters)'
if test -f 'arcdos.c'
then
echo shar: "will not over-write existing file 'arcdos.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcdos.c'
X/*
X * $Header: arcdos.c,v 1.8 88/08/01 15:07:15 hyc Exp $
X */
X
X/*
X * ARC - Archive utility - ARCDOS
X *
X * Version 1.44, created on 07/25/86 at 14:17:38
X *
X * (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains certain DOS level routines that assist in
X * doing fancy things with an archive, primarily reading and setting the date
X * and time last modified.
X *
X * These are, by nature, system dependant functions. But they are also, by
X * nature, very expendable.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X
X#if MSDOS
X#include "fileio2.h" /* needed for filehand */
X#endif
X
X#if UNIX
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <time.h>
X
Xstruct timeval { /* man page said <sys/types.h>, but it */
X long tv_sec; /* really seems to be in <sys/time.h>, */
X long tv_usec; /* but why bother... */
X};
X#endif
X
X#if GEMDOS
X#include <osbind.h>
X#endif
X
Xchar *strcpy(), *strcat(), *malloc();
X
Xvoid
Xgetstamp(f, date, time) /* get a file's date/time stamp */
X#if !MTS
X FILE *f; /* file to get stamp from */
X#else
X char *f; /* filename "" "" */
X#endif
X unsigned short *date, *time; /* storage for the stamp */
X{
X#if MSDOS
X struct {
X int ax, bx, cx, dx, si, di, ds, es;
X } reg;
X
X reg.ax = 0x5700; /* get date/time */
X reg.bx = filehand(f); /* file handle */
X if (sysint21(®, ®) & 1) /* DOS call */
X printf("Get timestamp fail (%d)\n", reg.ax);
X
X *date = reg.dx; /* save date/time */
X *time = reg.cx;
X#endif
X#if GEMDOS
X int fd, ret[2];
X
X fd = fileno(f);
X Fdatime(ret, fd, 0);
X *date = ret[1];
X *time = ret[0];
X#endif
X#if UNIX
X struct stat buf;
X struct tm *localtime(), *t;
X
X fstat(fileno(f), &buf);
X t=localtime(&(buf.st_mtime));
X *date = (unsigned short) (((t->tm_year - 80) << 9) +
X ((t->tm_mon + 1) << 5) + t->tm_mday);
X *time = (unsigned short) ((t->tm_hour << 11) +
X (t->tm_min << 5) + t->tm_sec / 2);
X#endif
X#if MTS
X fortran timein(),
X#if USEGFINFO
X gfinfo();
X#else
X fileinfo();
X#endif
X int stclk[2];
X char name[24];
X struct bigtime {
X int greg;
X int year;
X int mon;
X int day;
X int hour;
X int min;
X int sec;
X int usec;
X int week;
X int toff;
X int tzn1;
X int tzn2;
X } tvec;
X#if USEGFINFO
X static int gfflag = 0x0009, gfdummy[2] = {
X 0, 0
X };
X int gfcinfo[18];
X#else
X static int cattype = 2;
X#endif
X
X strcpy(name, f);
X strcat(name, " ");
X#if USEGFINFO
X gfcinfo[0] = 18;
X gfinfo(name, name, &gfflag, gfcinfo, gfdummy, gfdummy);
X timein("*IBM MICROSECONDS*", &gfcinfo[16], &tvec);
X#else
X fileinfo(name, &cattype, "CILCCT ", stclk);
X timein("*IBM MICROSECONDS*", stclk, &tvec);
X#endif
X
X *date = (unsigned short) (((tvec.year - 1980) << 9) + ((tvec.mon) << 5) + tvec.day);
X *time = (unsigned short) ((tvec.hour << 11) + (tvec.min << 5) + tvec.sec / 2);
X#endif
X}
X
Xvoid
Xsetstamp(f, date, time) /* set a file's date/time stamp */
X char *f; /* filename to stamp */
X unsigned short date, time; /* desired date, time */
X{
X#if MSDOS
X FILE *ff;
X struct {
X int ax, bx, cx, dx, si, di, ds, es;
X } reg;
X
X ff = fopen(f, "w+"); /* How else can I get a handle? */
X
X reg.ax = 0x5701; /* set date/time */
X reg.bx = filehand(f); /* file handle */
X reg.cx = time; /* desired time */
X reg.dx = date; /* desired date */
X if (sysint21(®, ®) & 1) /* DOS call */
X printf("Set timestamp fail (%d)\n", reg.ax);
X fclose(ff);
X#endif
X#if GEMDOS
X int fd, set[2];
X
X fd = Fopen(f, 0);
X set[0] = time;
X set[1] = date;
X Fdatime(set, fd, 1);
X Fclose(fd);
X#endif
X#if UNIX
X struct tm tm;
X struct timeval tvp[2];
X int utimes();
X long tmclock();
X tm.tm_sec = (time & 31) * 2;
X tm.tm_min = (time >> 5) & 63;
X tm.tm_hour = (time >> 11);
X tm.tm_mday = date & 31;
X tm.tm_mon = ((date >> 5) & 15) - 1;
X tm.tm_year = (date >> 9) + 80;
X tvp[0].tv_sec = tmclock(&tm);
X tvp[1].tv_sec = tvp[0].tv_sec;
X tvp[0].tv_usec = tvp[1].tv_usec = 0;
X utimes(f, tvp);
X#endif
X}
X
X#if MSDOS
Xint
Xfilehand(stream) /* find handle on a file */
X struct bufstr *stream; /* file to grab onto */
X{
X return stream->bufhand; /* return DOS 2.0 file handle */
X}
X#endif
X
X#if UNIX
Xint
Xizadir(filename) /* Is filename a directory? */
X char *filename;
X{
X struct stat buf;
X
X if (stat(filename, &buf) != 0)
X return (0); /* Ignore if stat fails since */
X else
X return (buf.st_mode & S_IFDIR); /* bad files trapped later */
X}
X#endif
SHAR_EOF
if test 4684 -ne "`wc -c < 'arcdos.c'`"
then
echo shar: "error transmitting 'arcdos.c'" '(should have been 4684 characters)'
fi
fi
echo shar: "extracting 'arcext.c'" '(5041 characters)'
if test -f 'arcext.c'
then
echo shar: "will not over-write existing file 'arcext.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcext.c'
X/*
X * $Header: arcext.c,v 1.5 88/06/01 19:26:31 hyc Locked $
X */
X
X/*
X * ARC - Archive utility - ARCEXT
X *
X * Version 2.19, created on 10/24/86 at 14:53:32
X *
X * (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
X *
X * By: Thom Henderson
X *
X * Description: This file contains the routines used to extract files from an
X * archive.
X *
X * Language: Computer Innovations Optimizing C86
X */
X#include <stdio.h>
X#include "arc.h"
X#if !MSDOS
X#include <ctype.h>
X#endif
X
Xvoid openarc(), closearc(), setstamp();
Xint free(), match(), readhdr(), unpack();
Xchar *strcpy(), *strcat();
X
Xvoid
Xextarc(num, arg, prt) /* extract files from archive */
X int num; /* number of arguments */
X char *arg[]; /* pointers to arguments */
X int prt; /* true if printing */
X{
X struct heads hdr; /* file header */
X int save; /* true to save current file */
X int did[MAXARG];/* true when argument was used */
X char *i, *rindex(); /* string index */
X char **name, *malloc(); /* name pointer list,
X * allocator */
X int n; /* index */
X void extfile();
X
X name = (char **) malloc(num * sizeof(char *)); /* get storage for name
X * pointers */
X
X for (n = 0; n < num; n++) { /* for each argument */
X did[n] = 0; /* reset usage flag */
X#if !MTS
X if (!(i = rindex(arg[n], '\\'))) /* find start of name */
X if (!(i = rindex(arg[n], '/')))
X if (!(i = rindex(arg[n], ':')))
X i = arg[n] - 1;
X#else
X if (!(i = rindex(arg[n], sepchr[0])))
X if (arg[n][0] != tmpchr[0])
X i = arg[n] - 1;
X else
X i = arg[n];
X#endif
X name[n] = i + 1;
X }
X
X
X openarc(0); /* open archive for reading */
X
X if (num) { /* if files were named */
X while (readhdr(&hdr, arc)) { /* while more files to check */
X save = 0; /* reset save flag */
X for (n = 0; n < num; n++) { /* for each template
X * given */
X if (match(hdr.name, name[n])) {
X save = 1; /* turn on save flag */
X did[n] = 1; /* turn on usage flag */
X break; /* stop looking */
X }
X }
X
X if (save) /* extract if desired, else skip */
X extfile(&hdr, arg[n], prt);
X else
X fseek(arc, hdr.size, 1);
X }
X } else
X while (readhdr(&hdr, arc)) /* else extract all files */
X extfile(&hdr, "", prt);
X
X closearc(0); /* close archive after reading */
X
X if (note) {
X for (n = 0; n < num; n++) { /* report unused args */
X if (!did[n]) {
X printf("File not found: %s\n", arg[n]);
X nerrs++;
X }
X }
X }
X free(name);
X}
X
Xvoid
Xextfile(hdr, path, prt) /* extract a file */
X struct heads *hdr; /* pointer to header data */
X char *path; /* pointer to path name */
X int prt; /* true if printing */
X{
X FILE *f, *fopen(); /* extracted file, opener */
X char buf[STRLEN]; /* input buffer */
X char fix[STRLEN]; /* fixed name buffer */
X char *i, *rindex(); /* string index */
X#ifdef LOCAL
X extern int unix_names;
X void lower();
X#endif /* LOCAL */
X
X if (prt) { /* printing is much easier */
X unpack(arc, stdout, hdr); /* unpack file from archive */
X printf("\f"); /* eject the form */
X return; /* see? I told you! */
X }
X strcpy(fix, path); /* note path name template */
X#if !MTS
X if (*path) {
X if (!(i = rindex(fix, '\\'))) /* find start of name */
X if (!(i = rindex(fix, '/')))
X if (!(i = rindex(fix, ':')))
X i = fix - 1;
X } else i = fix -1;
X#else
X if (!(i = rindex(fix, sepchr[0])))
X if (fix[0] != tmpchr[0])
X i = fix - 1;
X else
X i = fix;
X#endif
X#ifdef LOCAL
X if (!unix_names)
X lower(hdr->name);
X#endif /* LOCAL */
X strcpy(i + 1, hdr->name); /* replace template with name */
X
X if (note)
X printf("Extracting file: %s\n", fix);
X
X if (warn && !overlay) {
X if (f = fopen(fix, "r")) { /* see if it exists */
X fclose(f);
X printf("WARNING: File %s already exists!", fix);
X fflush(stdout);
X while (1) {
X printf(" Overwrite it (y/n)? ");
X fflush(stdout);
X fgets(buf, STRLEN, stdin);
X *buf = toupper(*buf);
X if (*buf == 'Y' || *buf == 'N')
X break;
X }
X if (*buf == 'N') {
X printf("%s not extracted.\n", fix);
X fseek(arc, hdr->size, 1);
X return;
X }
X }
X }
X#if !MTS
X if (!(f = fopen(fix, OPEN_W)))
X#else
X {
X fortran create();
X void memset();
X char c_name[256];
X struct crsize {
X short maxsize, cursize;
X } c_size;
X char c_vol[6];
X int c_type;
X strcpy(c_name, fix);
X strcat(c_name, " ");
X c_size.maxsize = 0;
X c_size.cursize = hdr->length / 4096 + 1;
X memset(c_vol, 0, sizeof(c_vol));
X c_type = 0x100;
X create(c_name, &c_size, c_vol, &c_type);
X }
X if (image) {
X f = fopen(fix, "wb");
X } else
X f = fopen(fix, "w");
X if (!f)
X#endif
X {
X if (warn) {
X printf("Cannot create %s\n", fix);
X nerrs++;
X }
X fseek(arc, hdr->size, 1);
X return;
X }
X /* now unpack the file */
X
X unpack(arc, f, hdr); /* unpack file from archive */
X fclose(f); /* all done writing to file */
X#if !MTS
X setstamp(fix, hdr->date, hdr->time); /* use filename for stamp */
X#endif
X}
SHAR_EOF
if test 5041 -ne "`wc -c < 'arcext.c'`"
then
echo shar: "error transmitting 'arcext.c'" '(should have been 5041 characters)'
fi
fi
echo shar: "extracting 'arcio.c'" '(7491 characters)'
if test -f 'arcio.c'
then
echo shar: "will not over-write existing file 'arcio.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arcio.c'
X/*
X * $Header: arcio.c,v 1.9 88/07/31 18:49:19 hyc Exp $
X */
X
X/* ARC - Archive utility - ARCIO
X
X Version 2.50, created on 04/22/87 at 13:25:20
X
X(C) COPYRIGHT 1985,86 by System Enhancement Associates; ALL RIGHTS RESERVED
X
X By: Thom Henderson
X
X Description:
X This file contains the file I/O routines used to manipulate
X an archive.
X
X Language:
X Computer Innovations Optimizing C86
X*/
X#include <stdio.h>
X#include "arc.h"
X#if MTS
X#include <ctype.h>
X#endif
X
Xvoid abort();
Xint strlen(), free();
X
Xint
Xreadhdr(hdr, f) /* read a header from an archive */
X struct heads *hdr; /* storage for header */
X FILE *f; /* archive to read header from */
X{
X#if !MSDOS
X unsigned char dummy[28];
X int i;
X#endif
X char name[FNLEN]; /* filename buffer */
X int try = 0;/* retry counter */
X static int first = 1; /* true only on first read */
X
X if (!f) /* if archive didn't open */
X return 0; /* then pretend it's the end */
X if (feof(f)) /* if no more data */
X return 0; /* then signal end of archive */
X
X if (fgetc(f) != ARCMARK) { /* check archive validity */
X if (warn) {
X printf("An entry in %s has a bad header.", arcname);
X nerrs++;
X }
X while (!feof(f)) {
X try++;
X if (fgetc(f) == ARCMARK) {
X ungetc(hdrver = fgetc(f), f);
X if (!(hdrver & 0x80) && hdrver <= ARCVER)
X break;
X }
X }
X
X if (feof(f) && first)
X abort("%s is not an archive", arcname);
X
X if (changing && warn)
X abort("%s is corrupted -- changes disallowed", arcname);
X
X if (warn)
X printf(" %d bytes skipped.\n", try);
X
X if (feof(f))
X return 0;
X }
X hdrver = fgetc(f); /* get header version */
X if (hdrver & 0x80) /* sign bit? negative? */
X abort("Invalid header in archive %s", arcname);
X if (hdrver == 0)
X return 0; /* note our end of archive marker */
X if (hdrver > ARCVER) {
X fread(name, sizeof(char), FNLEN, f);
X#if MTS
X atoe(name, strlen(name));
X#endif
X printf("I don't know how to handle file %s in archive %s\n",
X name, arcname);
X printf("I think you need a newer version of ARC.\n");
X exit(1);
X }
X /* amount to read depends on header type */
X
X if (hdrver == 1) { /* old style is shorter */
X fread(hdr, sizeof(struct heads) - sizeof(long int), 1, f);
X hdrver = 2; /* convert header to new format */
X hdr->length = hdr->size; /* size is same when not
X * packed */
X } else
X#if MSDOS
X fread(hdr, sizeof(struct heads), 1, f);
X#else
X fread(dummy, 27, 1, f);
X
X for (i = 0; i < FNLEN; hdr->name[i] = dummy[i], i++);
X#if MTS
X (void) atoe(hdr->name, strlen(hdr->name));
X#endif
X for (i = 0, hdr->size=0; i<4; hdr->size<<=8, hdr->size += dummy[16-i], i++);
X hdr->date = (short) ((dummy[18] << 8) + dummy[17]);
X hdr->time = (short) ((dummy[20] << 8) + dummy[19]);
X hdr->crc = (short) ((dummy[22] << 8) + dummy[21]);
X for (i = 0, hdr->length=0; i<4; hdr->length<<=8, hdr->length += dummy[26-i], i++);
X#endif
X
X if (hdr->date > olddate
X || (hdr->date == olddate && hdr->time > oldtime)) {
X olddate = hdr->date;
X oldtime = hdr->time;
X }
X first = 0;
X return 1; /* we read something */
X}
X
Xvoid
Xput_int(number, f) /* write a 2 byte integer */
X short number;
X FILE *f;
X{
X fputc((char) (number & 255), f);
X fputc((char) (number >> 8), f);
X}
X
Xvoid
Xput_long(number, f) /* write a 4 byte integer */
X long number;
X FILE *f;
X{
X put_int((short) (number & 0xFFFF), f);
X put_int((short) (number >> 16), f);
X}
X
Xvoid
Xwritehdr(hdr, f) /* write a header to an archive */
X struct heads *hdr; /* header to write */
X FILE *f; /* archive to write to */
X{
X fputc(ARCMARK, f); /* write out the mark of ARC */
X fputc(hdrver, f); /* write out the header version */
X if (!hdrver) /* if that's the end */
X return; /* then write no more */
X#if MSDOS
X fwrite(hdr, sizeof(struct heads), 1, f);
X#else
X /* byte/word ordering hassles... */
X#if MTS
X etoa(hdr->name, strlen(hdr->name));
X#endif
X fwrite(hdr->name, 1, FNLEN, f);
X put_long(hdr->size, f);
X put_int(hdr->date, f);
X put_int(hdr->time, f);
X put_int(hdr->crc, f);
X put_long(hdr->length, f);
X#endif
X
X /* note the newest file for updating the archive timestamp */
X
X if (hdr->date > arcdate
X || (hdr->date == arcdate && hdr->time > arctime)) {
X arcdate = hdr->date;
X arctime = hdr->time;
X }
X}
X
Xvoid
Xputc_tst(c, t) /* put a character, with tests */
X char c; /* character to output */
X FILE *t; /* file to write to */
X{
X c &= 0xff;
X if (t) {
X#if UNIX
X fputc(c, t);
X if (ferror(t))
X abort("Write failed");
X#else
X if (fputc(c, t) == EOF)
X abort("Write fail (disk full?)");
X#endif
X }
X}
X
X/*
X * NOTE: The filecopy() function is used to move large numbers of bytes from
X * one file to another. This particular version has been modified to improve
X * performance in Computer Innovations C86 version 2.3 in the small memory
X * model. It may not work as expected with other compilers or libraries, or
X * indeed with different versions of the CI-C86 compiler and library, or with
X * the same version in a different memory model.
X *
X * The following is a functional equivalent to the filecopy() routine that
X * should work properly on any system using any compiler, albeit at the cost
X * of reduced performance:
X *
X * filecopy(f,t,size)
X * FILE *f, *t; long size;
X * {
X * while(size--)
X * putc_tst(fgetc(f),t);
X * }
X */
X#if MSDOS
X#include <fileio2.h>
X
Xfilecopy(f, t, size) /* bulk file copier */
X FILE *f, *t; /* files from and to */
X long size; /* bytes to copy */
X{
X char *buf; /* buffer pointer */
X char *alloc();/* buffer allocator */
X unsigned int bufl; /* buffer length */
X unsigned int coreleft(); /* space available reporter */
X unsigned int cpy; /* bytes being copied */
X long floc, tloc, fseek(); /* file pointers, setter */
X struct regval reg; /* registers for DOS calls */
X
X if ((bufl = coreleft()) < 1000) /* see how much space we have */
X abort("Out of memory");
X bufl -= 1000; /* fudge factor for overhead */
X if (bufl > 60000)
X bufl = 60000; /* avoid choking alloc() */
X if (bufl > size)
X bufl = size; /* avoid wasting space */
X buf = alloc(bufl); /* allocate our buffer */
X
X floc = fseek(f, 0L, 1); /* reset I/O system */
X tloc = fseek(t, 0L, 1);
X
X segread(®.si); /* set segment registers for DOS */
X
X while (size > 0) { /* while more to copy */
X reg.ax = 0x3F00;/* read from handle */
X reg.bx = filehand(f);
X reg.cx = bufl < size ? bufl : size; /* amount to read */
X reg.dx = buf;
X if (sysint21(®, ®) & 1)
X abort("Read fail");
X
X cpy = reg.ax; /* amount actually read */
X reg.ax = 0x4000;/* write to handle */
X reg.bx = filehand(t);
X reg.cx = cpy;
X reg.dx = buf;
X sysint21(®, ®);
X
X if (reg.ax != cpy)
X abort("Write fail (disk full?)");
X
X size -= (long) cpy;
X }
X
X free(buf); /* all done with buffer */
X}
X#else
X
Xvoid
Xfilecopy(f, t, size) /* bulk file copier */
X FILE *f, *t; /* files from and to */
X long size; /* bytes to copy */
X{
X char *buf; /* buffer pointer */
X char *malloc(); /* buffer allocator */
X unsigned int bufl; /* buffer length */
X unsigned int cpy; /* bytes being copied */
X
X bufl = 32760;
X if (bufl > size)
X bufl = size; /* don't waste space */
X
X buf = malloc(bufl);
X
X while (size > 0) {
X cpy = fread(buf, sizeof(char),
X bufl < size ? bufl : (unsigned short) size, f);
X if (fwrite(buf, sizeof(char), cpy, t) != cpy)
X abort("Write fail (no space?)");
X size -= cpy;
X }
X
X free(buf);
X}
X#endif
SHAR_EOF
if test 7491 -ne "`wc -c < 'arcio.c'`"
then
echo shar: "error transmitting 'arcio.c'" '(should have been 7491 characters)'
fi
fi
echo shar: "extracting 'arclst.c'" '(4418 characters)'
if test -f 'arclst.c'
then
echo shar: "will not over-write existing file 'arclst.c'"
else
sed 's/^X//' << \SHAR_EOF > 'arclst.c'
X/*
X * $Header: arclst.c,v 1.5 88/06/01 18:05:57 hyc Locked $
X */
X
X/* ARC - Archive utility - ARCLST
X
X Version 2.39, created on 04/22/87 at 13:48:29
X
X(C) COPYRIGHT 1985-87 by System Enhancement Associates; ALL RIGHTS RESERVED
X
X By: Thom Henderson
X
X Description:
X This file contains the routines used to list the contents
X of an archive.
X
X Language:
X Computer Innovations Optimizing C86
X*/
X#include <stdio.h>
X#include "arc.h"
X
Xvoid rempath(), openarc(), closearc();
Xint readhdr(), match();
X
Xvoid
Xlstarc(num, arg) /* list files in archive */
X int num; /* number of arguments */
X char *arg[]; /* pointers to arguments */
X{
X struct heads hdr; /* header data */
X int list; /* true to list a file */
X int did[MAXARG]; /* true when argument was used */
X long tnum, tlen, tsize; /* totals */
X int n; /* index */
X void lstfile();
X
X tnum = tlen = tsize = 0;/* reset totals */
X
X for (n = 0; n < num; n++) /* for each argument */
X did[n] = 0; /* reset usage flag */
X rempath(num, arg); /* strip off paths */
X
X if (note && !kludge) {
X printf("Name Length ");
X if (bose)
X printf(" Stowage SF Size now");
X printf(" Date ");
X if (bose)
X printf(" Time CRC");
X printf("\n");
X
X printf("============ ========");
X if (bose)
X printf(" ======== ==== ========");
X printf(" =========");
X if (bose)
X printf(" ====== ====");
X printf("\n");
X }
X openarc(0); /* open archive for reading */
X
X if (num) { /* if files were named */
X while (readhdr(&hdr, arc)) { /* process all archive files */
X list = 0; /* reset list flag */
X for (n = 0; n < num; n++) { /* for each template
X * given */
X if (match(hdr.name, arg[n])) {
X list = 1; /* turn on list flag */
X did[n] = 1; /* turn on usage flag */
X break; /* stop looking */
X }
X }
X
X if (list) { /* if this file is wanted */
X if (!kludge)
X lstfile(&hdr); /* then tell about it */
X tnum++; /* update totals */
X tlen += hdr.length;
X tsize += hdr.size;
X }
X fseek(arc, hdr.size, 1); /* move to next header */
X }
X } else
X while (readhdr(&hdr, arc)) { /* else report on all files */
X if (!kludge)
X lstfile(&hdr);
X tnum++; /* update totals */
X tlen += hdr.length;
X tsize += hdr.size;
X fseek(arc, hdr.size, 1); /* skip to next header */
X }
X
X closearc(0); /* close archive after reading */
X
X if (note && !kludge) {
X printf(" ==== ========");
X if (bose)
X printf(" ==== ========");
X printf("\n");
X }
X if (note) {
X printf("Total %6ld %8ld", tnum, tlen);
X if (bose) {
X if (tlen)
X printf(" %3ld%%", 100L - (100L * tsize) / tlen);
X else
X printf(" ---");
X printf(" %8ld", tsize);
X }
X printf("\n");
X
X for (n = 0; n < num; n++) { /* report unused args */
X if (!did[n]) {
X printf("File not found: %s\n", arg[n]);
X nerrs++;
X }
X }
X }
X}
X
Xvoid
Xlstfile(hdr) /* tell about a file */
X struct heads *hdr; /* pointer to header data */
X{
X int yr, mo, dy; /* parts of a date */
X int hh, mm; /* parts of a time */
X
X static char *mon[] = /* month abbreviations */
X {
X "Jan", "Feb", "Mar", "Apr",
X "May", "Jun", "Jul", "Aug",
X "Sep", "Oct", "Nov", "Dec"
X };
X
X if (!note) { /* no notes means short listing */
X printf("%s\n", hdr->name);
X return;
X }
X
X yr = (hdr->date >> 9) & 0x7f; /* dissect the date */
X mo = (hdr->date >> 5) & 0x0f;
X dy = hdr->date & 0x1f;
X
X hh = (hdr->time >> 11) & 0x1f; /* dissect the time */
X mm = (hdr->time >> 5) & 0x3f;
X/* ss = (hdr->time & 0x1f) * 2; seconds, not used. */
X
X printf("%-12s %8ld ", hdr->name, hdr->length);
X
X if (bose) {
X switch (hdrver) {
X case 1:
X case 2:
X printf(" -- ");
X break;
X case 3:
X printf(" Packed ");
X break;
X case 4:
X printf("Squeezed");
X break;
X case 5:
X case 6:
X case 7:
X printf("crunched");
X break;
X case 8:
X printf("Crunched");
X break;
X case 9:
X printf("Squashed");
X break;
X default:
X printf("Unknown!");
X }
X
X if (hdr->length)
X printf(" %3ld%%", 100L - (100L * hdr->size) / hdr->length);
X else
X printf(" ---");
X printf(" %8ld ", hdr->size);
X }
X printf("%2d %3s %02d", dy, mon[mo - 1], (yr + 80) % 100);
X
X if (bose)
X printf(" %2d:%02d%c %04x",
X (hh > 12 ? hh - 12 : hh), mm, (hh > 11 ? 'p' : 'a'),
X hdr->crc & 0xffff);
X
X printf("\n");
X}
SHAR_EOF
if test 4418 -ne "`wc -c < 'arclst.c'`"
then
echo shar: "error transmitting 'arclst.c'" '(should have been 4418 characters)'
fi
fi
exit 0
# End of shell archive
More information about the Unix-pc.sources
mailing list