home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 9 Archive
/
09-Archive.zip
/
unzip532.zip
/
tandem
/
tandem.c
< prev
next >
Wrap
C/C++ Source or Header
|
1997-10-21
|
35KB
|
1,136 lines
/*
* routines common to TANDEM
*/
#define UNZIP_INTERNAL
#include "unzip.h"
#include <tal.h>
#include <cextdecs(FILE_GETINFOLISTBYNAME_, \
FILENAME_SCAN_, \
INTERPRETTIMESTAMP \
)>
#include <cextdecs(FILENAME_FINDSTART_, \
FILENAME_FINDNEXT_, \
FILENAME_FINDFINISH_ \
)>
#include <cextdecs(SETMODE)>
char *in2ex OF((char *));
void zexit(status)
int status;
{
terminate_program (0,0,status,,,); /* Exit(>0) creates saveabend files */
}
#ifdef fopen
# undef fopen
#endif
FILE *zipopen(fname, opt)
const char *fname;
const char *opt;
{
int fdesc;
if (strcmp(opt,FOPW) == 0)
if ((fdesc = creat(fname,,100,500)) != -1)
close(fdesc);
return fopen(fname,opt);
}
#define fopen zipopen
#ifdef putc
# undef putc
#endif
int zputc(ch, fptr)
int ch;
FILE *fptr;
{
int err;
err = putc(ch,fptr);
fflush(fptr);
return err;
}
#define putc zputc
int utime OF((char *, ztimbuf *));
int utime(file, time)
char *file;
ztimbuf *time;
{
return 0;
}
/* TANDEM version of chmod() function */
int chmod(file, unix_sec)
const char *file;
mode_t unix_sec;
{
FILE *stream;
struct nsk_sec_type {
unsigned progid : 1;
unsigned clear : 1;
unsigned null : 2;
unsigned read : 3;
unsigned write : 3;
unsigned execute: 3;
unsigned purge : 3;
};
union nsk_sec_ov {
struct nsk_sec_type bit_ov;
short int_ov;
};
union nsk_sec_ov nsk_sec;
short fnum, fdes, err, nsk_sec_int;
nsk_sec.bit_ov.progid = 0;
nsk_sec.bit_ov.clear = 0;
nsk_sec.bit_ov.null = 0;
/* 4="N", 5="C", 6="U", 7="-" */
err = unix_sec & S_IROTH;
if (unix_sec & S_IROTH) nsk_sec.bit_ov.read = 4;
else if (unix_sec & S_IRGRP) nsk_sec.bit_ov.read = 5;
else if (unix_sec & S_IRUSR) nsk_sec.bit_ov.read = 6;
else nsk_sec.bit_ov.read = 7;
if (unix_sec & S_IWOTH) nsk_sec.bit_ov.write = 4;
else if (unix_sec & S_IWGRP) nsk_sec.bit_ov.write = 5;
else if (unix_sec & S_IWUSR) nsk_sec.bit_ov.write = 6;
else nsk_sec.bit_ov.write = 7;
if (unix_sec & S_IXOTH) nsk_sec.bit_ov.execute = 4;
else if (unix_sec & S_IXGRP) nsk_sec.bit_ov.execute = 5;
else if (unix_sec & S_IXUSR) nsk_sec.bit_ov.execute = 6;
else nsk_sec.bit_ov.execute = 7;
nsk_sec.bit_ov.purge = nsk_sec.bit_ov.write;
nsk_sec_int = nsk_sec.int_ov;
fdes = open(file, (O_EXCLUSIVE | O_RDONLY));
fnum = fdtogfn (fdes);
err = SETMODE (fnum, SET_FILE_SECURITY, nsk_sec_int);
err = close(fdes);
}
/* TANDEM version of stat() function */
time_t gmt_to_time_t (long long *);
time_t gmt_to_time_t (gmt)
long long *gmt;
{
struct tm temp_tm;
short date_time[8];
long julian_dayno;
julian_dayno = INTERPRETTIMESTAMP (*gmt, date_time);
temp_tm.tm_sec = date_time[5];
temp_tm.tm_min = date_time[4];
temp_tm.tm_hour = date_time[3];
temp_tm.tm_mday = date_time[2];
temp_tm.tm_mon = date_time[1] - 1; /* C's so sad */
temp_tm.tm_year = date_time[0] - 1900; /* it's almost funny */
temp_tm.tm_isdst = -1; /* don't know */
return (mktime(&temp_tm));
}
short parsename( const char *, char *, char * );
short parsename(srce, fname, ext)
const char *srce;
char *fname;
char *ext;
{
/* As a way of supporting DOS extensions from Tandem we look for a space
separated extension string after the Guardian filename
e.g. ZIP ZIPFILE "$DATA4.TESTING.INVOICE TXT"
*/
char *fstart;
char *fptr;
short extension = 0;
*fname = *ext = '\0'; /* set to null string */
fstart = (char *) srce;
if ((fptr = strrchr(fstart, TANDEM_EXTENSION)) != NULL) {
extension = 1;
fptr++;
strncat(ext, fptr, _min(EXTENSION_MAX, strlen(fptr)));
fptr = strchr(fstart, TANDEM_EXTENSION); /* End of filename */
strncat(fname, fstart, _min(FILENAME_MAX, (fptr - fstart)));
}
else {
/* just copy string */
strncat(fname, srce, _min(FILENAME_MAX, strlen(srce)));
}
return extension;
}
int stat(n, s)
const char *n;
struct stat *s;
{
#define list_items 14
#define rlist_size 200
short err, i, extension;
char fname[FILENAME_MAX + 1];
short fnamelen;
char ext[EXTENSION_MAX + 1];
/* #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 #13 */
short ilist[list_items]={62,117,145,142,58,41,42,30,31,75, 78, 79, 60,119};
short ilen[list_items] ={ 2, 4, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4};
short ioff[list_items];
short rlist[rlist_size];
short extra[2];
short *rlen=&extra[0];
short *err_item=&extra[1];
unsigned short *fowner;
unsigned short *fprogid;
char *fsec;
short end, count, kind, level, options, searchid;
short info[5];
/* Initialise stat structure */
s->st_dev = _S_GUARDIANOBJECT;
s->st_ino = 0;
s->st_nlink = 0;
s->st_rdev = 0;
s->st_uid = s->st_gid = 0;
s->st_size = 0;
s->st_atime = s->st_ctime = s->st_mtime = 0;
s->st_reserved[0] = 0;
/* Check to see if name contains a (pseudo) file extension */
extension = parsename (n,fname,ext);
fnamelen = strlen(fname);
options = 3; /* Allow Subvols and Templates */
err = FILENAME_SCAN_( fname,
fnamelen,
&count,
&kind,
&level,
options
);
if (err != 0 || kind == 2) return -1;
if (kind == 1 || level < 2) {
/* Pattern, Subvol Name or One part Filename - lets see if it exists */
err = FILENAME_FINDSTART_ ( &searchid,
fname,
fnamelen,
,
DISK_DEVICE
);
if (err != 0) {
end = FILENAME_FINDFINISH_ ( searchid );
return -1;
}
err = FILENAME_FINDNEXT_ ( searchid,
fname,
FILENAME_MAX,
&fnamelen,
info
);
end = FILENAME_FINDFINISH_ ( searchid );
if (err != 0)
return -1; /* Non existing template, subvol or file */
if (kind == 1 || info[2] == -1) {
s->st_mode = S_IFDIR; /* Its an existing template or directory */
return 0;
}
/* Must be a real file so drop to code below to get info on it */
}
err = FILE_GETINFOLISTBYNAME_( fname,
fnamelen,
ilist,
list_items,
rlist,
rlist_size,
rlen,
err_item
);
if (err != 0) return -1;
ioff[0] = 0;
/* Build up table of offets into result list */
for (i=1; i < list_items; i++)
ioff[i] = ioff[i-1] + ilen[i-1];
/* Setup timestamps */
s->st_atime = gmt_to_time_t ((long long *)&rlist[ioff[1]]);
s->st_mtime = s->st_ctime = gmt_to_time_t ((long long *)&rlist[ioff[2]]);
s->st_reserved[0] = (int64_t) gmt_to_time_t ((long long *)&rlist[ioff[13]]);
s->st_size = *(off_t *)&rlist[ioff[3]];
fowner = (unsigned short *)&rlist[ioff[4]];
s->st_uid = *fowner & 0x00ff;
s->st_gid = *fowner >> 8;
/* Note that Purge security (fsec[3]) in NSK has no relevance to stat() */
fsec = (char *)&rlist[ioff[0]];
fprogid = (unsigned short *)&rlist[ioff[12]];
s->st_mode = S_IFREG | /* Regular File */
/* Parse Read Flag */
((fsec[0] & 0x03) == 0x00 ? S_IROTH : 0) |
((fsec[0] & 0x02) == 0x00 ? S_IRGRP : 0) |
((fsec[0] & 0x03) != 0x03 ? S_IRUSR : 0) |
/* Parse Write Flag */
((fsec[1] & 0x03) == 0x00 ? S_IWOTH : 0) |
((fsec[1] & 0x02) == 0x00 ? S_IWGRP : 0) |
((fsec[1] & 0x03) != 0x03 ? S_IWUSR : 0) |
/* Parse Execute Flag */
((fsec[2] & 0x03) == 0x00 ? S_IXOTH : 0) |
((fsec[2] & 0x02) == 0x00 ? S_IXGRP : 0) |
((fsec[2] & 0x03) != 0x03 ? S_IXUSR : 0) |
/* Parse Progid */
(*fprogid == 1 ? (S_ISUID | S_ISGID) : 0) ;
return 0;
}
/* TANDEM Directory processing */
DIR *opendir(const char *dirname)
{
short i, resolve;
char sname[FILENAME_MAX + 1];
short snamelen;
char fname[FILENAME_MAX + 1];
short fnamelen;
char *p;
short searchid, err, end;
struct dirent *entry;
DIR *dirp;
char ext[EXTENSION_MAX + 1];
short extension;
extension = parsename(dirname, sname, ext);
snamelen = strlen(sname);
/* First we work out how detailed the template is...
* e.g. If the template is DAVES*.* we want the search result
* in the same format
*/
p = sname;
i = 0;
while ((p = strchr(p, TANDEM_DELIMITER)) != NULL){
i++;
p++;
};
resolve = 2 - i;
/* Attempt to start a filename template */
err = FILENAME_FINDSTART_ ( &searchid,
sname,
snamelen,
resolve,
DISK_DEVICE
);
if (err != 0) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
/* Create DIR structure */
if ((dirp = malloc(sizeof(DIR))) == NULL ) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
dirp->D_list = dirp->D_curpos = NULL;
strcpy(dirp->D_path, dirname);
while ((err = FILENAME_FINDNEXT_(searchid,
fname,
FILENAME_MAX,
&fnamelen
)
) == 0 ){
/* Create space for entry */
if ((entry = malloc (sizeof(struct dirent))) == NULL) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
/* Link to last entry */
if (dirp->D_curpos == NULL)
dirp->D_list = dirp->D_curpos = entry; /* First name */
else {
dirp->D_curpos->d_next = entry; /* Link */
dirp->D_curpos = entry;
};
/* Add directory entry */
*dirp->D_curpos->d_name = '\0';
strncat(dirp->D_curpos->d_name,fname,fnamelen);
if (extension) {
strcat(dirp->D_curpos->d_name,TANDEM_EXTENSION_STR);
strcat(dirp->D_curpos->d_name,ext);
};
dirp->D_curpos->d_next = NULL;
};
end = FILENAME_FINDFINISH_(searchid);
if (err = 1) { /* Should return EOF at end of search */
dirp->D_curpos = dirp->D_list; /* Set current pos to start */
return dirp;
} else
return NULL;
}
struct dirent *readdir(DIR *dirp)
{
struct dirent *cur;
cur = dirp->D_curpos;
dirp->D_curpos = dirp->D_curpos->d_next;
return cur;
}
void rewinddir(DIR *dirp)
{
dirp->D_curpos = dirp->D_list;
}
int closedir(DIR *dirp)
{
struct dirent *node;
while (dirp->D_list != NULL) {
node = dirp->D_list;
dirp->D_list = dirp->D_list->d_next;
free( node );
}
free( dirp );
return 0;
}
static int created_dir; /* used in mapname(), checkdir() */
static int renamed_fullpath; /* ditto */
/**********************/
/* Function do_wild() */ /* for porting: dir separator; match(ignore_case) */
/**********************/
char *do_wild(__G__ wildspec)
__GDEF
char *wildspec; /* only used first time on a given dir */
{
static DIR *dir = (DIR *)NULL;
static char *dirname, *wildname, matchname[FILNAMSIZ];
static int firstcall=TRUE, have_dirname, dirnamelen;
struct dirent *file;
static char *intname;
int isdir = 0;
int pdosflag = 0;
/* Even when we're just returning wildspec, we *always* do so in
* matchname[]--calling routine is allowed to append four characters
* to the returned string, and wildspec may be a pointer to argv[].
*/
if (firstcall) { /* first call: must initialize everything */
firstcall = FALSE;
dirnamelen = strlen(wildspec);
if ((dirname = (char *)malloc(dirnamelen+1)) == (char *)NULL) {
Info(slide, 0x201, ((char *)slide,
"warning: cannot allocate wildcard buffers\n"));
strcpy(matchname, wildspec);
return matchname; /* but maybe filespec was not a wildcard */
}
strcpy(dirname, wildspec);
wildname = wildspec;
have_dirname = FALSE;
if ((dir = opendir(dirname)) != (DIR *)NULL) {
while ((file = readdir(dir)) != (struct dirent *)NULL) {
if (file->d_name[0] == '.' && wildname[0] != '.')
continue; /* Unix: '*' and '?' do not match leading dot */
if (match(file->d_name, wildname, 0)) { /* 0 == case sens. */
if (have_dirname) {
strcpy(matchname, dirname);
strcpy(matchname+dirnamelen, file->d_name);
} else
strcpy(matchname, file->d_name);
return matchname;
}
}
/* if we get to here directory is exhausted, so close it */
closedir(dir);
dir = (DIR *)NULL;
}
/* return the raw wildspec in case that works (e.g., directory not
* searchable, but filespec was not wild and file is readable) */
strcpy(matchname, wildspec);
return matchname;
}
/* last time through, might have failed opendir but returned raw wildspec */
if (dir == (DIR *)NULL) {
firstcall = TRUE; /* nothing left to try--reset for new wildspec */
if (have_dirname)
free(dirname);
return (char *)NULL;
}
/* If we've gotten this far, we've read and matched at least one entry
* successfully (in a previous call), so dirname has been copied into
* matchname already.
*/
while ((file = readdir(dir)) != (struct dirent *)NULL)
if (match(file->d_name, wildname, 0)) { /* 0 == don't ignore case */
if (have_dirname) {
/* strcpy(matchname, dirname); */
strcpy(matchname+dirnamelen, file->d_name);
} else
strcpy(matchname, file->d_name);
return matchname;
}
closedir(dir); /* have read at least one dir entry; nothing left */
dir = (DIR *)NULL;
firstcall = TRUE; /* reset for new wildspec */
if (have_dirname)
free(dirname);
return (char *)NULL;
} /* end function do_wild() */
/**********************/
/* Function mapattr() */
/**********************/
int mapattr(__G)
__GDEF
{
ulg tmp = G.crec.external_file_attributes;
switch (G.pInfo->hostnum) {
case UNIX_:
case TANDEM_:
G.pInfo->file_attr = (unsigned)(tmp >> 16);
return 0;
case AMIGA_:
tmp = (unsigned)(tmp>>17 & 7); /* Amiga RWE bits */
G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);
break;
/* all remaining cases: expand MSDOS read-only bit into write perms */
case FS_FAT_:
case FS_HPFS_:
case FS_NTFS_:
case MAC_:
case ATARI_: /* (used to set = 0666) */
case TOPS20_:
case VMS_:
default:
tmp = !(tmp & 1) << 1; /* read-only bit --> write perms bits */
G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);
break;
} /* end switch (host-OS-created-by) */
/* for originating systems with no concept of "group," "other," "system": */
umask( (int)(tmp=umask(0)) ); /* apply mask to expanded r/w(/x) perms */
G.pInfo->file_attr &= ~tmp;
return 0;
} /* end function mapattr() */
/************************/
/* Function mapname() */
/************************/
int mapname(__G__ renamed) /* return 0 if no error, 1 if caution (filename */
__GDEF /* truncated), 2 if warning (skip file because */
int renamed; /* dir doesn't exist), 3 if error (skip file), */
{ /* 10 if no memory (skip file) */
char pathcomp[FILNAMSIZ]; /* path-component buffer */
char *pp, *cp=(char *)NULL; /* character pointers */
char *lastsemi=(char *)NULL; /* pointer to last semi-colon in pathcomp */
int quote = FALSE; /* flags */
int error = 0;
register unsigned workch; /* hold the character being tested */
/*---------------------------------------------------------------------------
Initialize various pointers and counters and stuff.
---------------------------------------------------------------------------*/
if (G.pInfo->vollabel)
return IZ_VOL_LABEL; /* can't set disk volume labels in Unix */
/* can create path as long as not just freshening, or if user told us */
G.create_dirs = (!G.fflag || renamed);
created_dir = FALSE; /* not yet */
/* user gave full pathname: don't prepend rootpath */
renamed_fullpath = (renamed && (*G.filename == '/'));
if (checkdir(__G__ (char *)NULL, INIT) == 10)
return 10; /* initialize path buffer, unless no memory */
*pathcomp = '\0'; /* initialize translation buffer */
pp = pathcomp; /* point to translation buffer */
/* TANDEM - call in2ex */
strcpy (pathcomp, G.filename);
strcpy (G.filename, in2ex(pathcomp));
*pathcomp = '\0';
if (G.jflag) /* junking directories */
cp = (char *)strrchr(G.filename, TANDEM_DELIMITER);
if (cp == (char *)NULL) /* no '/' or not junking dirs */
cp = G.filename; /* point to internal zipfile-member pathname */
else
++cp; /* point to start of last component of path */
/*---------------------------------------------------------------------------
Begin main loop through characters in filename.
---------------------------------------------------------------------------*/
while ((workch = (uch)*cp++) != 0) {
if (quote) { /* if character quoted, */
*pp++ = (char)workch; /* include it literally */
quote = FALSE;
} else
switch (workch) {
case TANDEM_DELIMITER: /* can assume -j flag not given */
*pp = '\0';
if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1)
return error;
pp = pathcomp; /* reset conversion buffer for next piece */
lastsemi = (char *)NULL; /* leave directory semi-colons alone */
break;
case ';': /* VMS version (or DEC-20 attrib?) */
lastsemi = pp;
*pp++ = ';'; /* keep for now; remove VMS ";##" */
break; /* later, if requested */
case '\026': /* control-V quote for special chars */
quote = TRUE; /* set flag for next character */
break;
case ' ': /* remove spaces for Tandem */
break;
default:
/* allow European characters in filenames: */
if (isprint(workch) || (128 <= workch && workch <= 254))
*pp++ = (char)workch;
} /* end switch */
} /* end while loop */
*pp = '\0'; /* done with pathcomp: terminate it */
/* if not saving them, remove VMS version numbers (appended ";###") */
if (!G.V_flag && lastsemi) {
pp = lastsemi + 1;
while (isdigit((uch)(*pp)))
++pp;
if (*pp == '\0') /* only digits between ';' and end: nuke */
*lastsemi = '\0';
}
/*---------------------------------------------------------------------------
Report if directory was created (and no file to create: filename ended
in '/'), check name to be sure it exists, and combine path and name be-
fore exiting.
---------------------------------------------------------------------------*/
if (G.filename[strlen(G.filename) - 1] == TANDEM_DELIMITER) {
checkdir(__G__ G.filename, GETPATH);
if (created_dir && QCOND2) {
Info(slide, 0, ((char *)slide, " creating: %s\n", G.filename));
return IZ_CREATED_DIR; /* set dir time (note trailing '/') */
}
return 2; /* dir existed already; don't look for data to extract */
}
if (*pathcomp == '\0') {
Info(slide, 1, ((char *)slide, "mapname: conversion of %s failed\n",
G.filename));
return 3;
}
checkdir(__G__ pathcomp, APPEND_NAME); /* returns 1 if truncated: care? */
checkdir(__G__ G.filename, GETPATH);
return error;
} /* end function mapname() */
/***********************/
/* Function checkdir() */
/***********************/
int checkdir(__G__ pathcomp, flag)
__GDEF
char *pathcomp;
int flag;
/*
* returns: 1 - (on APPEND_NAME) truncated filename
* 2 - path doesn't exist, not allowed to create
* 3 - path doesn't exist, tried to create and failed; or
* path exists and is not a directory, but is supposed to be
* 4 - path is too long
* 10 - can't allocate memory for filename buffers
*/
{
static int rootlen = 0; /* length of rootpath */
static char *rootpath; /* user's "extract-to" directory */
static char *buildpath; /* full path (so far) to extracted file */
static char *end; /* pointer to end of buildpath ('\0') */
# define FN_MASK 7
# define FUNCTION (flag & FN_MASK)
/*---------------------------------------------------------------------------
APPEND_DIR: append the path component to the path being built and check
for its existence. If doesn't exist and we are creating directories, do
so for this one; else signal success or error as appropriate.
---------------------------------------------------------------------------*/
if (FUNCTION == APPEND_DIR) {
int too_long = FALSE;
#ifdef SHORT_NAMES
char *old_end = end;
#endif
Trace((stderr, "appending dir segment [%s]\n", pathcomp));
while ((*end = *pathcomp++) != '\0')
++end;
#ifdef SHORT_NAMES /* path components restricted to 14 chars, typically */
if ((end-old_end) > FILENAME_MAX) /* GRR: proper constant? */
*(end = old_end + FILENAME_MAX) = '\0';
#endif
/* GRR: could do better check, see if overrunning buffer as we go:
* check end-buildpath after each append, set warning variable if
* within 20 of FILNAMSIZ; then if var set, do careful check when
* appending. Clear variable when begin new path. */
if ((end-buildpath) > FILNAMSIZ-3) /* need '/', one-char name, '\0' */
too_long = TRUE; /* check if extracting directory? */
if (stat(buildpath, &G.statbuf)) { /* path doesn't exist */
if (!G.create_dirs) { /* told not to create (freshening) */
free(buildpath);
return 2; /* path doesn't exist: nothing to do */
}
if (too_long) {
Info(slide, 1, ((char *)slide,
"checkdir error: path too long: %s\n", buildpath));
free(buildpath);
return 4; /* no room for filenames: fatal */
}
if (mkdir(buildpath, 0777) == -1) { /* create the directory */
Info(slide, 1, ((char *)slide,
"checkdir error: cannot create %s\n\
unable to process %s.\n", buildpath, G.filename));
free(buildpath);
return 3; /* path didn't exist, tried to create, failed */
}
created_dir = TRUE;
} else if (!S_ISDIR(G.statbuf.st_mode)) {
Info(slide, 1, ((char *)slide,
"checkdir error: %s exists but is not directory\n\
unable to process %s.\n", buildpath, G.filename));
free(buildpath);
return 3; /* path existed but wasn't dir */
}
if (too_long) {
Info(slide, 1, ((char *)slide,
"checkdir error: path too long: %s\n", buildpath));
free(buildpath);
return 4; /* no room for filenames: fatal */
}
*end++ = TANDEM_DELIMITER;
*end = '\0';
Trace((stderr, "buildpath now = [%s]\n", buildpath));
return 0;
} /* end if (FUNCTION == APPEND_DIR) */
/*---------------------------------------------------------------------------
GETPATH: copy full path to the string pointed at by pathcomp, and free
buildpath.
---------------------------------------------------------------------------*/
if (FUNCTION == GETPATH) {
strcpy(pathcomp, buildpath);
Trace((stderr, "getting and freeing path [%s]\n", pathcomp));
free(buildpath);
buildpath = end = (char *)NULL;
return 0;
}
/*---------------------------------------------------------------------------
APPEND_NAME: assume the path component is the filename; append it and
return without checking for existence.
---------------------------------------------------------------------------*/
if (FUNCTION == APPEND_NAME) {
#ifdef SHORT_NAMES
char *old_end = end;
#endif
Trace((stderr, "appending filename [%s]\n", pathcomp));
while ((*end = *pathcomp++) != '\0') {
++end;
#ifdef SHORT_NAMES /* truncate name at 14 characters, typically */
if ((end-old_end) > FILENAME_MAX) /* GRR: proper constant? */
*(end = old_end + FILENAME_MAX) = '\0';
#endif
if ((end-buildpath) >= FILNAMSIZ) {
*--end = '\0';
Info(slide, 0x201, ((char *)slide,
"checkdir warning: path too long; truncating\n\
%s\n -> %s\n", G.filename, buildpath));
return 1; /* filename truncated */
}
}
Trace((stderr, "buildpath now = [%s]\n", buildpath));
return 0; /* could check for existence here, prompt for new name... */
}
/*---------------------------------------------------------------------------
INIT: allocate and initialize buffer space for the file currently being
extracted. If file was renamed with an absolute path, don't prepend the
extract-to path.
---------------------------------------------------------------------------*/
/* GRR: for VMS and TOPS-20, add up to 13 to strlen */
if (FUNCTION == INIT) {
Trace((stderr, "initializing buildpath to "));
if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+1)) ==
(char *)NULL)
return 10;
if ((rootlen > 0) && !renamed_fullpath) {
strcpy(buildpath, rootpath);
end = buildpath + rootlen;
} else {
*buildpath = '\0';
end = buildpath;
}
Trace((stderr, "[%s]\n", buildpath));
return 0;
}
/*---------------------------------------------------------------------------
ROOT: if appropriate, store the path in rootpath and create it if neces-
sary; else assume it's a zipfile member and return. This path segment
gets used in extracting all members from every zipfile specified on the
command line.
---------------------------------------------------------------------------*/
#if (!defined(SFX) || defined(SFX_EXDIR))
if (FUNCTION == ROOT) {
Trace((stderr, "initializing root path to [%s]\n", pathcomp));
if (pathcomp == (char *)NULL) {
rootlen = 0;
return 0;
}
if ((rootlen = strlen(pathcomp)) > 0) {
if (pathcomp[rootlen-1] == TANDEM_DELIMITER) {
pathcomp[--rootlen] = '\0';
}
if (rootlen > 0 && (stat(pathcomp, &G.statbuf) ||
!S_ISDIR(G.statbuf.st_mode))) /* path does not exist */
{
if (!G.create_dirs /* || iswild(pathcomp) */ ) {
rootlen = 0;
return 2; /* skip (or treat as stored file) */
}
/* create the directory (could add loop here to scan pathcomp
* and create more than one level, but why really necessary?) */
if (mkdir(pathcomp, 0777) == -1) {
Info(slide, 1, ((char *)slide,
"checkdir: cannot create extraction directory: %s\n",
pathcomp));
rootlen = 0; /* path didn't exist, tried to create, and */
return 3; /* failed: file exists, or 2+ levels required */
}
}
if ((rootpath = (char *)malloc(rootlen+2)) == (char *)NULL) {
rootlen = 0;
return 10;
}
strcpy(rootpath, pathcomp);
rootpath[rootlen++] = TANDEM_DELIMITER;
rootpath[rootlen] = '\0';
Trace((stderr, "rootpath now = [%s]\n", rootpath));
}
return 0;
}
#endif /* !SFX || SFX_EXDIR */
/*---------------------------------------------------------------------------
END: free rootpath, immediately prior to program exit.
---------------------------------------------------------------------------*/
if (FUNCTION == END) {
Trace((stderr, "freeing rootpath\n"));
if (rootlen > 0) {
free(rootpath);
rootlen = 0;
}
return 0;
}
return 99; /* should never reach */
} /* end function checkdir() */
/********************/
/* Function mkdir() */
/********************/
int mkdir(path, mode)
const char *path; /* both */
mode_t mode; /* ignored */
/*
* returns: 0 - successful
* -1 - failed (errno not set, however)
*/
{
return 0;
}
/************************/
/* Function version() */
/************************/
void version(__G)
__GDEF
{
/* Pyramid, NeXT have problems with huge macro expansion, too: no Info() */
sprintf((char *)slide, LoadFarString(CompiledWith),
#ifdef __GNUC__
"gcc ", __VERSION__,
#else
# ifdef __VERSION__
"cc ", __VERSION__,
# else
"cc", "",
# endif
#endif
"Unix",
#ifdef TANDEM
" (Tandem/NSK)",
#else
"",
#endif /* TANDEM */
#ifdef __DATE__
" on ", __DATE__
#else
"", ""
#endif
);
(*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);
} /* end function version() */
/****************************/
/* Function close_outfile() */
/****************************/
void close_outfile(__G) /* GRR: change to return PK-style warning level */
__GDEF
{
ztimbuf tp;
ush z_uidgid[2];
unsigned eb_izux_len;
/*---------------------------------------------------------------------------
If symbolic links are supported, allocate a storage area, put the uncom-
pressed "data" in it, and create the link. Since we know it's a symbolic
link to start with, we shouldn't have to worry about overflowing unsigned
ints with unsigned longs.
---------------------------------------------------------------------------*/
#ifdef SYMLINKS
if (G.symlnk) {
unsigned ucsize = (unsigned)G.lrec.ucsize;
char *linktarget = (char *)malloc((unsigned)G.lrec.ucsize+1);
fclose(G.outfile); /* close "data" file... */
G.outfile = fopen(G.filename, FOPR); /* ...and reopen for reading */
if (!linktarget || fread(linktarget, 1, ucsize, G.outfile) !=
(int)ucsize)
{
Info(slide, 0x201, ((char *)slide,
"warning: symbolic link (%s) failed\n", G.filename));
if (linktarget)
free(linktarget);
fclose(G.outfile);
return;
}
fclose(G.outfile); /* close "data" file for good... */
unlink(G.filename); /* ...and delete it */
linktarget[ucsize] = '\0';
if (QCOND2)
Info(slide, 0, ((char *)slide, "-> %s ", linktarget));
if (symlink(linktarget, G.filename)) /* create the real link */
perror("symlink error");
free(linktarget);
return; /* can't set time on symlinks */
}
#endif /* SYMLINKS */
fclose(G.outfile);
/*---------------------------------------------------------------------------
Change the file permissions from default ones to those stored in the
zipfile.
---------------------------------------------------------------------------*/
#ifndef NO_CHMOD
if (chmod(G.filename, 0xffff & G.pInfo->file_attr))
perror("chmod (file attributes) error");
#endif
tp.actime = tp.modtime = dos_to_unix_time(G.lrec.last_mod_file_date,
G.lrec.last_mod_file_time);
TTrace((stderr, "\nclose_outfile: modification/access times = %ld\n",
tp.modtime));
/* set the file's access and modification times */
if (utime(G.filename, &tp))
#ifdef AOS_VS
Info(slide, 0x201, ((char *)slide, "... cannot set time for %s",
G.filename));
#else
Info(slide, 0x201, ((char *)slide,
"warning: cannot set the time for %s\n", G.filename));
#endif
} /* end function close_outfile() */
/********************/ /* swiped from Zip: convert the zip file name to */
/* Function in2ex() */ /* an external file name, returning the malloc'd */
/********************/ /* string or NULL if not enough memory. */
char *in2ex(n)
char *n; /* internal file name */
{
char *x; /* external file name */
char *t; /* pointer to internal */
char *p; /* pointer to internal */
char *e; /* pointer to internal */
int len;
if ((x = malloc(strlen(n) + 4)) == NULL) /* + 4 for safety */
return NULL;
*x= '\0';
if ((t = strrchr(n, INTERNAL_DELIMITER)) != NULL)
++t;
else
t = n;
/* GRR: t is already pointing *after* the last INTERNAL_DELIMITER... ? */
while (*t != '\0') { /* File part could be sys,vol,subvol or file */
if (*t == INTERNAL_DELIMITER) { /* System, Volume or Subvol Name */
t++;
if (*t == INTERNAL_DELIMITER) { /* System */
strcat(x, TANDEM_NODE_STR);
t++;
} else
strcat(x, TANDEM_DELIMITER_STR);
}
p = strchr(t, INTERNAL_DELIMITER);
if (p == NULL)
break;
if ((e = strchr(t,DOS_EXTENSION)) == NULL)
e = p;
else
e = (e < p ? e : p);
len = _min(MAXFILEPARTLEN, (e - t));
strncat(x, t, (e - t));
t = p;
}
if ((e = strchr(t, DOS_EXTENSION)) == NULL)
strcat(x, t);
else
strncat(x,t,(e - t));
return x;
}