💾 Archived View for mirrors.apple2.org.za › archive › ground.icaen.uiowa.edu › unix › Nulib.v324 › n… captured on 2023-01-29 at 11:02:16.
-=-=-=-=-=-=-
/*
* nublu.c - operations on Binary II archives
*
* NuLib v3.2 March 1992 Freeware (distribute, don't sell)
* By Andy McFadden (fadden@uts.amdahl.com)
*/
#ifdef APW
segment "Compress"
#endif
#ifndef NO_BLU /***********************************/
#include "nudefs.h"
#include <stdio.h>
#include <fcntl.h>
#ifdef UNIX
# include <errno.h>
# include <sys/types.h>
# include <sys/stat.h>
#endif
#ifdef APW
# include <prodos.h>
#endif
#ifdef MSDOS
# include <stdlib.h>
# include <io.h>
# include <string.h>
# include <sys/types.h>
# include <sys/stat.h>
#endif
#include "nuview.h" /* file types for BLU */
#include "nuadd.h" /* need OptNum() */
#include "nupak.h" /* need unpak_SQU */
#include "nuetc.h"
/* Binary II extraction routines are adapted from: */
/*************************************************************************
** **
** Name : unblu **
** Author : Marcel J.E. Mol **
** Date : 10/05/88 (first release) **
** Version : 2.20 **
** Files : unblu.c Main source file **
** **
** ------------------------- Revision List ------------------------- **
** Ver Date Name Remarks **
** 1.00 10/05/88 Marcel Mol Raw copy of a basic program**
** 2.00 03/06/88 Marcel Mol Rewrite after blu info **
** was send to the net **
** 2.10 18/06/88 Marcel Mol Added filetype texts **
** 2.20 23/09/88 Marcel Mol Show mod and creation time **
** **
************************************************************************/
/*char * copyright = "@(#) unblu.c 2.1 18/06/88 (c) M.J.E. Mol";*/
#define BUFSIZE 128 /* Blu block length */
/* global variables */
static char *progname;
static char *blufile;
static BOOLEAN extract = FALSE; /* extract (as opposed to just listing) */
/*
* extract_file -- extract file fname from the archive fd. Fname
* contains filelen bytes.
*
* If the first block has the .QQ magic numbers, go ahead and try to
* unsqueeze it. Not the best way to go about it, but it works.
*/
static void
extract_file(fd, fname, filelen)
int fd;
char *fname; /* 64 bytes */
long filelen;
{
int ofd;
int n, i;
int j, len;
onebyt buf[BUFSIZE];
long full_len;
int offset;
static char *procName = "extract_file";
/*n = */ read(fd, buf, 70); /* read first few bytes */
lseek(fd, (off_t) -70, S_REL); /* back up */
if ((buf[0] == 0x76) && (buf[1] == 0xff)) { /* is it squeezed? */
i = 0; /* get the original file name */
while ((fname[i] = buf[4+i]) != '\0')
i++;
offset = 5+i; /* how far into file is end of filename? */
ConvFileName(fname);
if (verbose) { printf("(as %s)...", fname); fflush(stdout); }
}
ConvFileName(fname); /* strip hi bits, adjust special chars, etc */
len = strlen(fname); /* (no longer used?) */
#ifdef FUBAR
for (j = 0; j < len; j++)
fname[j] &= 0x7f; /* clear hi bits */
#endif
if (Exists(fname)) {
if (interact) {
if (verbose) printf("file exists, overwite");
else printf("%s exists, overwite", fname);
if (!AskYesNo()) { /* return w/o overwriting */
full_len = ( (filelen / 128L) +1 ) * 128L;
lseek(fd, (off_t) full_len, S_REL);
return;
}
}
if (verbose) { printf("overwriting..."); fflush(stdout); }
if (unlink(fname) < 0)
Fatal("Unable to remove existing file", procName);
}
if ((ofd = open(fname, O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, (mode_t)0644))<0){
Fatal("Can't open destination file", "extract_file");
}
if ((buf[0] == 0x76) && (buf[1] == 0xff)) { /* is it squeezed? */
if (verbose) { printf("unsqueezing..."); fflush(stdout); }
full_len = ( (filelen / 128L) +1 ) * 128L;
lseek(fd, (off_t) offset, S_REL);
full_len -= offset; /* send unpak_SQU everything past fname */
unpak_SQU(fd, ofd, full_len); /* unsqueeze it */
} else { /* extract uncompressed */
lastseen = '\0'; /* used by crlf() translator */
while (filelen > 0L) {
n = read(fd, buf, BUFSIZE); /* Read 128 bytes */
if (n != BUFSIZE) {
fprintf(stderr, "Extract_BNY: %s file size broken\n", blufile);
Quit(-1);
}
if (crlf(ofd, buf, (filelen >= BUFSIZE ? BUFSIZE : filelen)) !=
(filelen >= BUFSIZE ? BUFSIZE : filelen))
Fatal("Bad write", procName);
filelen -= (long) BUFSIZE;
}
}
close(ofd); /* Close destination file */
}
/*
* print_header -- print global information of the binary II file
*/
static void
print_header(buf)
onebyt *buf;
{
long disk_blocks;
disk_blocks = buf[117] + (buf[118]<<8) + (buf[119]<<16) + (buf[120]<<24);
printf("Listing %-40.40s ", blufile);
printf("Blocks used: %-5ld", disk_blocks);
printf("Files: %d\n", buf[127]+1);
printf("\nFilename Type Blocks Modified ");
printf("Created Length Subtype\n\n");
}
/*
* want -- return TRUE if name exists in array wantlist,
* else return FALSE
*/
static BOOLEAN
want(name, wantlist)
char *name;
char **wantlist;
{
while (*wantlist != NULL) {
if (strcasecmp(name, *wantlist++) == 0)
return (TRUE);
}
return (FALSE);
}
/*
* process_file -- retrieve or print file information of file given
* in buf
*/
static void
process_file(fd, buf, count, wanted)
int fd;
onebyt *buf;
int count;
char **wanted;
{
int ftype, auxtype;
int fnamelen;
long filelen;
char fname[64];
char outbuf[16]; /* temp for sprintf */
int nblocks, problocks;
Time create_dt;
Time mod_dt;
#ifdef APW
FileRec frec;
#endif
#ifdef UNIX
struct stat st;
#endif
#ifdef MSDOS
struct stat st;
#endif
/* +PORT+ */
/* int tf;
* int dflags;
*/
static char *procName = "process_file";
/* Get file info */
ftype = buf[4]; /* File type */
auxtype = (int) buf[5] + ((int)buf[6] << 8);
fnamelen = buf[23]; /* filename */
strncpy(fname, &buf[24], fnamelen);
fname[fnamelen] = '\0';
/* dflags = buf[125]; /* Data flags */
/* tf = buf[127]; /* Number of files to follow */
filelen = (long) buf[20] + ((long) buf[21] << 8) +
((long) buf[22] << 16); /* calculate file len */
nblocks = (filelen + BUFSIZE-1) / BUFSIZE; /* #of BNY blocks */
problocks = buf[8] + ((int) buf[9] << 8);
mod_dt.second = 0;
mod_dt.minute = buf[12] & 0x3f;
mod_dt.hour = buf[13] & 0x1f;
mod_dt.day = (buf[10] & 0x1f) -1;
mod_dt.month = (((buf[11] & 0x01) << 3) + (buf[10] >> 5)) -1;
mod_dt.year = buf[11] >> 1;
mod_dt.weekDay= 0;
create_dt.second = 0;
create_dt.minute = buf[16] & 0x3f;
create_dt.hour = buf[17] & 0x1f;
create_dt.day = (buf[14] & 0x1f) -1;
create_dt.month = (((buf[15] & 0x01) << 3) + (buf[14] >> 5)) -1;
create_dt.year = buf[15] >> 1;
create_dt.weekDay= 0;
if (!count || want(fname, wanted)) {
if (!extract) { /* print file information ONLY */
printf("%-15.15s %-3.3s ", fname, FT[ftype]);
printf("%6d ", problocks);
printf("%-16.16s ", PrintDate(&mod_dt, TRUE));
printf("%-16.16s ", PrintDate(&create_dt, TRUE));
if (filelen < 0x100L)
sprintf(outbuf, "$%.2lx", filelen);
else if (filelen < 0x10000L)
sprintf(outbuf, "$%.4lx", filelen);
else sprintf(outbuf, "$%.6lx", filelen);
printf("%7s ", outbuf);
printf("$%.4x\n", auxtype);
/* if (dflags == 0)
* printf("stored");
* else {
* if (dflags & 128) {
* printf("squeezed");
* }
* if (dflags & 64) {
* printf("encrypted");
* }
* if (dflags & 1)
* printf("packed");
* }
* putchar('\n');
*/
if (ftype != 15) { /* If not a directory */
lseek(fd, (off_t) BUFSIZE*nblocks, S_REL); /*Seek to next file*/
}
} else { /* extract is TRUE */
if (verbose) { printf("Extracting %s...", fname); fflush(stdout); }
#ifdef UNIX
if (ftype != 15)
extract_file(fd, fname, filelen); /* note dates etc not set */
else {
/* if no directory exists, then make one */
if (stat(fname, &st) < 0)
if (errno == ENOENT) {
sprintf(tmpNameBuf, "mkdir %s", fname);
if (system(tmpNameBuf) != 0) /* call UNIX mkdir */
Fatal("Unable to create subdir", procName);
} else {
Fatal("Unable to create dir", procName);
}
}
#else
# ifdef APW
/* create file/directory , with appropriate type/auxtype stuff */
c2pstr(fname);
frec.pathname = fname;
frec.fAccess = 0x00e3; /* unlocked */
frec.fileType = ftype;
frec.auxType = (unsigned long) auxtype;
frec.storageType = (int) buf[7];
frec.createDate = 0x0000; /* set later */
frec.createTime = 0x0000;
CREATE( &frec );
ToolErrChk();
p2cstr(fname);
extract_file(fd, fname, filelen);
/* set file attributes */
c2pstr(fname);
frec.fAccess = (word) buf[3];
frec.modDate = (word) buf[10] + ((word)buf[11] << 8);
frec.modTime = (word) buf[12] + ((word)buf[13] << 8);
frec.createDate = (word) buf[14] + ((word)buf[15] << 8);
frec.createTime = (word) buf[16] + ((word)buf[17] << 8);
SET_FILE_INFO( &frec );
ToolErrChk();
p2cstr(fname);
# else
if (ftype != 15)
extract_file(fd, fname, filelen);
else /* +PORT+ */
printf("[ need [other] subdir create for UnBNY ]\n");
# endif /* APW */
#endif /* UNIX */
if (verbose) printf("done.\n");
}
} else if (ftype != 15) { /* This file not wanted; if not a directory */
lseek(fd, (off_t) BUFSIZE*nblocks, S_REL); /* Seek to next file */
}
}
/*
* unblu -- process a binary II file fd, and process the filenames
* listed in wanted. If wanted is \0, all files are processed.
*/
static void
unblu(fd, count, wanted)
int fd;
int count;
char **wanted;
{
onebyt buf[BUFSIZE];
int firstblock = 1; /* First block needs special processing */
int tofollow = 1; /* Files to follow in the archive */
int n;
while (tofollow && ((n = read(fd, buf, BUFSIZE)) > 0)) {
/* If there is a header block */
if (n != BUFSIZE) {
fprintf(stderr, "UnBNY: %s file size is broken\n", blufile);
Quit(-1);
}
if ((buf[0] != 10) || (buf[1] != 71) ||
(buf[2] != 76) || (buf[18] != 2)) {
fprintf(stderr,
"UnBNY: %s not a Binary II file or bad record\n", blufile);
Quit(-1);
}
tofollow = buf[127]; /* How many files to follow */
if (firstblock && !extract) {
print_header(buf);
}
firstblock = 0;
process_file(fd, buf, count, wanted); /* process the file for it */
}
if (firstblock && (n < 0)) /* length < 128 */
fprintf(stderr, "UnBNY: Not a Binary II file");
}
/*
* Main entry point from CShrink
*/
void
NuBNY(filename, argc, argv, options)
char *filename;
int argc;
char **argv;
char *options;
{
int bfd; /* File descriptor for blu file */
char *optr;
/* process X subopt ourselves */
if (INDEX(options+1, 'x')) extract = TRUE;
else extract = FALSE;
blufile = filename; /* Make it global */
if ((bfd = open(filename, O_RDONLY | O_BINARY)) < 0)
Fatal("Unable to open Binary II archive", "NuBNY");
unblu(bfd, argc, argv); /* Process wanted files */
close(bfd);
Quit(0);
}
#endif /*NO_BLU*/ /***********************************/