2553 lines
82 KiB
C
2553 lines
82 KiB
C
/*
|
|
Copyright (c) 1990-2002 Info-ZIP. All rights reserved.
|
|
|
|
See the accompanying file LICENSE, version 2000-Apr-09 or later
|
|
(the contents of which are also included in unzip.h) for terms of use.
|
|
If, for some reason, all these files are missing, the Info-ZIP license
|
|
also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
|
|
*/
|
|
/*---------------------------------------------------------------------------
|
|
|
|
fileio.c
|
|
|
|
This file contains routines for doing direct but relatively generic input/
|
|
output, file-related sorts of things, plus some miscellaneous stuff. Most
|
|
of the stuff has to do with opening, closing, reading and/or writing files.
|
|
|
|
Contains: open_input_file()
|
|
open_outfile() (not: VMS, AOS/VS, CMSMVS, MACOS, TANDEM)
|
|
undefer_input()
|
|
defer_leftover_input()
|
|
readbuf()
|
|
readbyte()
|
|
fillinbuf()
|
|
seek_zipf()
|
|
flush() (non-VMS)
|
|
is_vms_varlen_txt() (non-VMS, VMS_TEXT_CONV only)
|
|
disk_error() (non-VMS)
|
|
UzpMessagePrnt()
|
|
UzpMessageNull() (DLL only)
|
|
UzpInput()
|
|
UzpMorePause()
|
|
UzpPassword() (non-WINDLL)
|
|
handler()
|
|
dos_to_unix_time() (non-VMS, non-VM/CMS, non-MVS)
|
|
check_for_newer() (non-VMS, non-OS/2, non-VM/CMS, non-MVS)
|
|
do_string()
|
|
makeword()
|
|
makelong()
|
|
str2iso() (CRYPT && NEED_STR2ISO, only)
|
|
str2oem() (CRYPT && NEED_STR2OEM, only)
|
|
memset() (ZMEM only)
|
|
memcpy() (ZMEM only)
|
|
zstrnicmp() (NO_STRNICMP only)
|
|
zstat() (REGULUS only)
|
|
plastchar() (_MBCS only)
|
|
uzmbschr() (_MBCS && NEED_UZMBSCHR, only)
|
|
uzmbsrchr() (_MBCS && NEED_UZMBSRCHR, only)
|
|
fLoadFarString() (SMALL_MEM only)
|
|
fLoadFarStringSmall() (SMALL_MEM only)
|
|
fLoadFarStringSmall2() (SMALL_MEM only)
|
|
zfstrcpy() (SMALL_MEM only)
|
|
|
|
---------------------------------------------------------------------------*/
|
|
|
|
|
|
#define __FILEIO_C /* identifies this source module */
|
|
#define UNZIP_INTERNAL
|
|
#include "unzip.h"
|
|
#ifdef WINDLL
|
|
# include "windll/windll.h"
|
|
# include <setjmp.h>
|
|
#endif
|
|
#include "crypt.h"
|
|
#include "ttyio.h"
|
|
|
|
/* setup of codepage conversion for decryption passwords */
|
|
#if CRYPT
|
|
# if (defined(CRYP_USES_ISO2OEM) && !defined(IZ_ISO2OEM_ARRAY))
|
|
# define IZ_ISO2OEM_ARRAY /* pull in iso2oem[] table */
|
|
# endif
|
|
# if (defined(CRYP_USES_OEM2ISO) && !defined(IZ_OEM2ISO_ARRAY))
|
|
# define IZ_OEM2ISO_ARRAY /* pull in oem2iso[] table */
|
|
# endif
|
|
#endif
|
|
#include "ebcdic.h" /* definition/initialization of ebcdic[] */
|
|
|
|
|
|
/*
|
|
Note: Under Windows, the maximum size of the buffer that can be used
|
|
with any of the *printf calls is 16,384, so win_fprintf was used to
|
|
feed the fprintf clone no more than 16K chunks at a time. This should
|
|
be valid for anything up to 64K (and probably beyond, assuming your
|
|
buffers are that big).
|
|
*/
|
|
#ifdef WINDLL
|
|
# define WriteError(buf,len,strm) \
|
|
(win_fprintf(pG, strm, (extent)len, (char far *)buf) != (int)(len))
|
|
#else /* !WINDLL */
|
|
# ifdef USE_FWRITE
|
|
# define WriteError(buf,len,strm) \
|
|
((extent)fwrite((char *)(buf),1,(extent)(len),strm) != (extent)(len))
|
|
# else
|
|
# define WriteError(buf,len,strm) \
|
|
((extent)write(fileno(strm),(char *)(buf),(extent)(len)) != (extent)(len))
|
|
# endif
|
|
#endif /* ?WINDLL */
|
|
|
|
#if (defined(USE_DEFLATE64) && defined(__16BIT__))
|
|
static int partflush OF((__GPRO__ uch *rawbuf, ulg size, int unshrink));
|
|
#endif
|
|
#ifdef VMS_TEXT_CONV
|
|
static int is_vms_varlen_txt OF((__GPRO__ uch *ef_buf, unsigned ef_len));
|
|
#endif
|
|
static int disk_error OF((__GPRO));
|
|
|
|
|
|
/****************************/
|
|
/* Strings used in fileio.c */
|
|
/****************************/
|
|
|
|
static ZCONST char Far CannotOpenZipfile[] =
|
|
"error: cannot open zipfile [ %s ]\n";
|
|
|
|
#if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
|
|
#if (!defined(TANDEM))
|
|
#if (defined(BEO_THS_UNX) || defined(DOS_FLX_NLM_OS2_W32))
|
|
static ZCONST char Far CannotDeleteOldFile[] =
|
|
"error: cannot delete old %s\n";
|
|
#ifdef UNIXBACKUP
|
|
static ZCONST char Far CannotRenameOldFile[] =
|
|
"error: cannot rename old %s\n";
|
|
static ZCONST char Far BackupSuffix[] = "~";
|
|
#endif
|
|
#endif /* BEO_THS_UNX || DOS_FLX_NLM_OS2_W32 */
|
|
#ifdef NOVELL_BUG_FAILSAFE
|
|
static ZCONST char Far NovellBug[] =
|
|
"error: %s: stat() says does not exist, but fopen() found anyway\n";
|
|
#endif
|
|
static ZCONST char Far CannotCreateFile[] = "error: cannot create %s\n";
|
|
#endif /* !TANDEM */
|
|
#endif /* !VMS && !AOS_VS && !CMS_MVS && !MACOS */
|
|
|
|
static ZCONST char Far ReadError[] = "error: zipfile read error\n";
|
|
static ZCONST char Far FilenameTooLongTrunc[] =
|
|
"warning: filename too long--truncating.\n";
|
|
static ZCONST char Far ExtraFieldTooLong[] =
|
|
"warning: extra field too long (%d). Ignoring...\n";
|
|
|
|
#ifdef WINDLL
|
|
static ZCONST char Far DiskFullQuery[] =
|
|
"%s: write error (disk full?).\n";
|
|
#else
|
|
static ZCONST char Far DiskFullQuery[] =
|
|
"%s: write error (disk full?). Continue? (y/n/^C) ";
|
|
static ZCONST char Far ZipfileCorrupt[] =
|
|
"error: zipfile probably corrupt (%s)\n";
|
|
# ifdef SYMLINKS
|
|
static ZCONST char Far FileIsSymLink[] =
|
|
"%s exists and is a symbolic link%s.\n";
|
|
# endif
|
|
# ifdef MORE
|
|
static ZCONST char Far MorePrompt[] = "--More--(%lu)";
|
|
# endif
|
|
static ZCONST char Far QuitPrompt[] =
|
|
"--- Press `Q' to quit, or any other key to continue ---";
|
|
static ZCONST char Far HidePrompt[] = /* "\r \r"; */
|
|
"\r \r";
|
|
# if CRYPT
|
|
# ifdef MACOS
|
|
/* SPC: are names on MacOS REALLY so much longer than elsewhere ??? */
|
|
static ZCONST char Far PasswPrompt[] = "[%s]\n %s password: ";
|
|
# else
|
|
static ZCONST char Far PasswPrompt[] = "[%s] %s password: ";
|
|
# endif
|
|
static ZCONST char Far PasswPrompt2[] = "Enter password: ";
|
|
static ZCONST char Far PasswRetry[] = "password incorrect--reenter: ";
|
|
# endif /* CRYPT */
|
|
#endif /* !WINDLL */
|
|
|
|
|
|
|
|
|
|
|
|
/******************************/
|
|
/* Function open_input_file() */
|
|
/******************************/
|
|
|
|
int open_input_file(__G) /* return 1 if open failed */
|
|
__GDEF
|
|
{
|
|
/*
|
|
* open the zipfile for reading and in BINARY mode to prevent cr/lf
|
|
* translation, which would corrupt the bitstreams
|
|
*/
|
|
|
|
#ifdef VMS
|
|
G.zipfd = open(G.zipfn, O_RDONLY, 0, "ctx=stm");
|
|
#else /* !VMS */
|
|
#ifdef MACOS
|
|
G.zipfd = open(G.zipfn, 0);
|
|
#else /* !MACOS */
|
|
#ifdef CMS_MVS
|
|
G.zipfd = vmmvs_open_infile(__G);
|
|
#else /* !CMS_MVS */
|
|
#ifdef USE_STRM_INPUT
|
|
G.zipfd = fopen(G.zipfn, FOPR);
|
|
#else /* !USE_STRM_INPUT */
|
|
# ifdef O_BINARY
|
|
G.zipfd = open(G.zipfn, O_RDONLY | O_BINARY);
|
|
# else
|
|
G.zipfd = open(G.zipfn, O_RDONLY);
|
|
# endif
|
|
#endif /* ?USE_STRM_INPUT */
|
|
#endif /* ?CMS_MVS */
|
|
#endif /* ?MACOS */
|
|
#endif /* ?VMS */
|
|
|
|
#ifdef USE_STRM_INPUT
|
|
if (G.zipfd == NULL)
|
|
#else
|
|
/* if (G.zipfd < 0) */ /* no good for Windows CE port */
|
|
if (G.zipfd == -1)
|
|
#endif
|
|
{
|
|
Info(slide, 0x401, ((char *)slide, LoadFarString(CannotOpenZipfile),
|
|
G.zipfn));
|
|
return 1;
|
|
}
|
|
return 0;
|
|
|
|
} /* end function open_input_file() */
|
|
|
|
|
|
|
|
|
|
#if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
|
|
#if (!defined(TANDEM))
|
|
|
|
/***************************/
|
|
/* Function open_outfile() */
|
|
/***************************/
|
|
|
|
int open_outfile(__G) /* return 1 if fail */
|
|
__GDEF
|
|
{
|
|
#ifdef DLL
|
|
if (G.redirect_data)
|
|
return (redirect_outfile(__G) == FALSE);
|
|
#endif
|
|
#ifdef QDOS
|
|
QFilename(__G__ G.filename);
|
|
#endif
|
|
#if (defined(DOS_FLX_NLM_OS2_W32) || defined(BEO_THS_UNX))
|
|
#ifdef BORLAND_STAT_BUG
|
|
/* Borland 5.0's stat() barfs if the filename has no extension and the
|
|
* file doesn't exist. */
|
|
if (access(G.filename, 0) == -1) {
|
|
FILE *tmp = fopen(G.filename, "wb+");
|
|
|
|
/* file doesn't exist, so create a dummy file to keep stat() from
|
|
* failing (will be over-written anyway) */
|
|
fputc('0', tmp); /* just to have something in the file */
|
|
fclose(tmp);
|
|
}
|
|
#endif /* BORLAND_STAT_BUG */
|
|
#ifdef SYMLINKS
|
|
if (SSTAT(G.filename, &G.statbuf) == 0 || lstat(G.filename,&G.statbuf) == 0)
|
|
#else
|
|
if (SSTAT(G.filename, &G.statbuf) == 0)
|
|
#endif /* ?SYMLINKS */
|
|
{
|
|
Trace((stderr, "open_outfile: stat(%s) returns 0: file exists\n",
|
|
FnFilter1(G.filename)));
|
|
#ifdef UNIXBACKUP
|
|
if (uO.B_flag) { /* do backup */
|
|
char *tname;
|
|
struct stat tmpstat;
|
|
int blen, flen, tlen;
|
|
|
|
blen = strlen(BackupSuffix);
|
|
flen = strlen(G.filename);
|
|
tlen = flen + blen + 6; /* includes space for 5 digits */
|
|
if (tlen >= FILNAMSIZ) { /* in case name is too long, truncate */
|
|
tname = (char *)malloc(FILNAMSIZ);
|
|
if (tname == NULL)
|
|
return 1; /* in case we run out of space */
|
|
tlen = FILNAMSIZ - 1 - blen;
|
|
strcpy(tname, G.filename); /* make backup name */
|
|
tname[tlen] = '\0';
|
|
if (flen > tlen) flen = tlen;
|
|
tlen = FILNAMSIZ;
|
|
} else {
|
|
tname = (char *)malloc(tlen);
|
|
if (tname == NULL)
|
|
return 1; /* in case we run out of space */
|
|
strcpy(tname, G.filename); /* make backup name */
|
|
}
|
|
strcpy(tname+flen, BackupSuffix);
|
|
|
|
if (IS_OVERWRT_ALL) {
|
|
/* If there is a previous backup file, delete it,
|
|
* otherwise the following rename operation may fail.
|
|
*/
|
|
if (SSTAT(tname, &tmpstat) == 0)
|
|
unlink(tname);
|
|
} else {
|
|
/* Check if backupname exists, and, if it's true, try
|
|
* appending numbers of up to 5 digits to the BackupSuffix,
|
|
* until an unused name is found.
|
|
*/
|
|
unsigned maxtail, i;
|
|
char *numtail = tname + flen + blen;
|
|
|
|
maxtail = 65535;
|
|
switch (tlen - flen - blen - 1) {
|
|
case 4: maxtail = 9999; break;
|
|
case 3: maxtail = 999; break;
|
|
case 2: maxtail = 99; break;
|
|
case 1: maxtail = 9; break;
|
|
case 0: maxtail = 0; break;
|
|
}
|
|
/* while filename exists */
|
|
for (i = 0; (i <= maxtail) && (SSTAT(tname, &tmpstat) == 0);)
|
|
sprintf(numtail,"%u", ++i);
|
|
}
|
|
|
|
if (rename(G.filename, tname) != 0) { /* move file */
|
|
Info(slide, 0x401, ((char *)slide,
|
|
LoadFarString(CannotRenameOldFile), FnFilter1(G.filename)));
|
|
free(tname);
|
|
return 1;
|
|
}
|
|
Trace((stderr, "open_outfile: %s now renamed into %s\n",
|
|
FnFilter1(G.filename), FnFilter2(tname)));
|
|
free(tname);
|
|
} else
|
|
#endif /* UNIXBACKUP */
|
|
{
|
|
#ifdef DOS_FLX_OS2_W32
|
|
if (!(G.statbuf.st_mode & S_IWRITE)) {
|
|
Trace((stderr,
|
|
"open_outfile: existing file %s is read-only\n",
|
|
FnFilter1(G.filename)));
|
|
chmod(G.filename, S_IREAD | S_IWRITE);
|
|
Trace((stderr, "open_outfile: %s now writable\n",
|
|
FnFilter1(G.filename)));
|
|
}
|
|
#endif /* DOS_FLX_OS2_W32 */
|
|
#ifdef NLM
|
|
/* Give the file read/write permission (non-POSIX shortcut) */
|
|
chmod(G.filename, 0);
|
|
#endif /* NLM */
|
|
if (unlink(G.filename) != 0) {
|
|
Info(slide, 0x401, ((char *)slide,
|
|
LoadFarString(CannotDeleteOldFile), FnFilter1(G.filename)));
|
|
return 1;
|
|
}
|
|
Trace((stderr, "open_outfile: %s now deleted\n",
|
|
FnFilter1(G.filename)));
|
|
}
|
|
}
|
|
#endif /* DOS_FLX_NLM_OS2_W32 || BEO_THS_UNX */
|
|
#ifdef RISCOS
|
|
if (SWI_OS_File_7(G.filename,0xDEADDEAD,0xDEADDEAD,G.lrec.ucsize)!=NULL) {
|
|
Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
|
|
FnFilter1(G.filename)));
|
|
return 1;
|
|
}
|
|
#endif /* RISCOS */
|
|
#ifdef TOPS20
|
|
char *tfilnam;
|
|
|
|
if ((tfilnam = (char *)malloc(2*strlen(G.filename)+1)) == (char *)NULL)
|
|
return 1;
|
|
strcpy(tfilnam, G.filename);
|
|
upper(tfilnam);
|
|
enquote(tfilnam);
|
|
if ((G.outfile = fopen(tfilnam, FOPW)) == (FILE *)NULL) {
|
|
Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
|
|
tfilnam));
|
|
free(tfilnam);
|
|
return 1;
|
|
}
|
|
free(tfilnam);
|
|
#else /* !TOPS20 */
|
|
#ifdef MTS
|
|
if (uO.aflag)
|
|
G.outfile = fopen(G.filename, FOPWT);
|
|
else
|
|
G.outfile = fopen(G.filename, FOPW);
|
|
if (G.outfile == (FILE *)NULL) {
|
|
Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
|
|
FnFilter1(G.filename)));
|
|
return 1;
|
|
}
|
|
#else /* !MTS */
|
|
#ifdef DEBUG
|
|
Info(slide, 1, ((char *)slide,
|
|
"open_outfile: doing fopen(%s) for reading\n", FnFilter1(G.filename)));
|
|
if ((G.outfile = fopen(G.filename, FOPR)) == (FILE *)NULL)
|
|
Info(slide, 1, ((char *)slide,
|
|
"open_outfile: fopen(%s) for reading failed: does not exist\n",
|
|
FnFilter1(G.filename)));
|
|
else {
|
|
Info(slide, 1, ((char *)slide,
|
|
"open_outfile: fopen(%s) for reading succeeded: file exists\n",
|
|
FnFilter1(G.filename)));
|
|
fclose(G.outfile);
|
|
}
|
|
#endif /* DEBUG */
|
|
#ifdef NOVELL_BUG_FAILSAFE
|
|
if (G.dne && ((G.outfile = fopen(G.filename, FOPR)) != (FILE *)NULL)) {
|
|
Info(slide, 0x401, ((char *)slide, LoadFarString(NovellBug),
|
|
FnFilter1(G.filename)));
|
|
fclose(G.outfile);
|
|
return 1; /* with "./" fix in checkdir(), should never reach here */
|
|
}
|
|
#endif /* NOVELL_BUG_FAILSAFE */
|
|
Trace((stderr, "open_outfile: doing fopen(%s) for writing\n",
|
|
FnFilter1(G.filename)));
|
|
if ((G.outfile = fopen(G.filename, FOPW)) == (FILE *)NULL) {
|
|
Info(slide, 0x401, ((char *)slide, LoadFarString(CannotCreateFile),
|
|
FnFilter1(G.filename)));
|
|
return 1;
|
|
}
|
|
Trace((stderr, "open_outfile: fopen(%s) for writing succeeded\n",
|
|
FnFilter1(G.filename)));
|
|
#endif /* !MTS */
|
|
#endif /* !TOPS20 */
|
|
|
|
#ifdef USE_FWRITE
|
|
#ifdef DOS_NLM_OS2_W32
|
|
/* 16-bit MSC: buffer size must be strictly LESS than 32K (WSIZE): bogus */
|
|
setbuf(G.outfile, (char *)NULL); /* make output unbuffered */
|
|
#else /* !DOS_NLM_OS2_W32 */
|
|
#ifndef RISCOS
|
|
#ifdef _IOFBF /* make output fully buffered (works just about like write()) */
|
|
setvbuf(G.outfile, (char *)slide, _IOFBF, WSIZE);
|
|
#else
|
|
setbuf(G.outfile, (char *)slide);
|
|
#endif
|
|
#endif /* !RISCOS */
|
|
#endif /* ?DOS_NLM_OS2_W32 */
|
|
#endif /* USE_FWRITE */
|
|
#ifdef OS2_W32
|
|
/* preallocate the final file size to prevent file fragmentation */
|
|
SetFileSize(G.outfile, G.pInfo->uncompr_size);
|
|
#endif
|
|
return 0;
|
|
|
|
} /* end function open_outfile() */
|
|
|
|
#endif /* !TANDEM */
|
|
#endif /* !VMS && !AOS_VS && !CMS_MVS && !MACOS */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* These functions allow NEXTBYTE to function without needing two bounds
|
|
* checks. Call defer_leftover_input() if you ever have filled G.inbuf
|
|
* by some means other than readbyte(), and you then want to start using
|
|
* NEXTBYTE. When going back to processing bytes without NEXTBYTE, call
|
|
* undefer_input(). For example, extract_or_test_member brackets its
|
|
* central section that does the decompression with these two functions.
|
|
* If you need to check the number of bytes remaining in the current
|
|
* file while using NEXTBYTE, check (G.csize + G.incnt), not G.csize.
|
|
*/
|
|
|
|
/****************************/
|
|
/* function undefer_input() */
|
|
/****************************/
|
|
|
|
void undefer_input(__G)
|
|
__GDEF
|
|
{
|
|
if (G.incnt > 0)
|
|
G.csize += G.incnt;
|
|
if (G.incnt_leftover > 0) {
|
|
/* We know that "(G.csize < MAXINT)" so we can cast G.csize to int:
|
|
* This condition was checked when G.incnt_leftover was set > 0 in
|
|
* defer_leftover_input(), and it is NOT allowed to touch G.csize
|
|
* before calling undefer_input() when (G.incnt_leftover > 0)
|
|
* (single exception: see read_byte()'s "G.csize <= 0" handling) !!
|
|
*/
|
|
G.incnt = G.incnt_leftover + (int)G.csize;
|
|
G.inptr = G.inptr_leftover - (int)G.csize;
|
|
G.incnt_leftover = 0;
|
|
} else if (G.incnt < 0)
|
|
G.incnt = 0;
|
|
} /* end function undefer_input() */
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************/
|
|
/* function defer_leftover_input() */
|
|
/***********************************/
|
|
|
|
void defer_leftover_input(__G)
|
|
__GDEF
|
|
{
|
|
if ((long)G.incnt > G.csize) {
|
|
/* (G.csize < MAXINT), we can safely cast it to int !! */
|
|
if (G.csize < 0L)
|
|
G.csize = 0L;
|
|
G.inptr_leftover = G.inptr + (int)G.csize;
|
|
G.incnt_leftover = G.incnt - (int)G.csize;
|
|
G.incnt = (int)G.csize;
|
|
} else
|
|
G.incnt_leftover = 0;
|
|
G.csize -= G.incnt;
|
|
} /* end function defer_leftover_input() */
|
|
|
|
|
|
|
|
|
|
|
|
/**********************/
|
|
/* Function readbuf() */
|
|
/**********************/
|
|
|
|
unsigned readbuf(__G__ buf, size) /* return number of bytes read into buf */
|
|
__GDEF
|
|
char *buf;
|
|
register unsigned size;
|
|
{
|
|
register unsigned count;
|
|
unsigned n;
|
|
|
|
n = size;
|
|
while (size) {
|
|
if (G.incnt <= 0) {
|
|
if ((G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) == 0)
|
|
return (n-size);
|
|
else if (G.incnt < 0) {
|
|
/* another hack, but no real harm copying same thing twice */
|
|
(*G.message)((zvoid *)&G,
|
|
(uch *)LoadFarString(ReadError), /* CANNOT use slide */
|
|
(ulg)strlen(LoadFarString(ReadError)), 0x401);
|
|
return 0; /* discarding some data; better than lock-up */
|
|
}
|
|
/* buffer ALWAYS starts on a block boundary: */
|
|
G.cur_zipfile_bufstart += INBUFSIZ;
|
|
G.inptr = G.inbuf;
|
|
}
|
|
count = MIN(size, (unsigned)G.incnt);
|
|
memcpy(buf, G.inptr, count);
|
|
buf += count;
|
|
G.inptr += count;
|
|
G.incnt -= count;
|
|
size -= count;
|
|
}
|
|
return n;
|
|
|
|
} /* end function readbuf() */
|
|
|
|
|
|
|
|
|
|
|
|
/***********************/
|
|
/* Function readbyte() */
|
|
/***********************/
|
|
|
|
int readbyte(__G) /* refill inbuf and return a byte if available, else EOF */
|
|
__GDEF
|
|
{
|
|
if (G.mem_mode)
|
|
return EOF;
|
|
if (G.csize <= 0) {
|
|
G.csize--; /* for tests done after exploding */
|
|
G.incnt = 0;
|
|
return EOF;
|
|
}
|
|
if (G.incnt <= 0) {
|
|
if ((G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) == 0) {
|
|
G.incnt = 0; /* do not allow negative value to affect stuff */
|
|
return EOF;
|
|
} else if (G.incnt < 0) { /* "fail" (abort, retry, ...) returns this */
|
|
/* another hack, but no real harm copying same thing twice */
|
|
(*G.message)((zvoid *)&G,
|
|
(uch *)LoadFarString(ReadError),
|
|
(ulg)strlen(LoadFarString(ReadError)), 0x401);
|
|
echon();
|
|
#ifdef WINDLL
|
|
longjmp(dll_error_return, 1);
|
|
#else
|
|
DESTROYGLOBALS();
|
|
EXIT(PK_BADERR); /* totally bailing; better than lock-up */
|
|
#endif
|
|
}
|
|
G.cur_zipfile_bufstart += INBUFSIZ; /* always starts on block bndry */
|
|
G.inptr = G.inbuf;
|
|
defer_leftover_input(__G); /* decrements G.csize */
|
|
}
|
|
|
|
#if CRYPT
|
|
if (G.pInfo->encrypted) {
|
|
uch *p;
|
|
int n;
|
|
|
|
/* This was previously set to decrypt one byte beyond G.csize, when
|
|
* incnt reached that far. GRR said, "but it's required: why?" This
|
|
* was a bug in fillinbuf() -- was it also a bug here?
|
|
*/
|
|
for (n = G.incnt, p = G.inptr; n--; p++)
|
|
zdecode(*p);
|
|
}
|
|
#endif /* CRYPT */
|
|
|
|
--G.incnt;
|
|
return *G.inptr++;
|
|
|
|
} /* end function readbyte() */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef USE_ZLIB
|
|
|
|
/************************/
|
|
/* Function fillinbuf() */
|
|
/************************/
|
|
|
|
int fillinbuf(__G) /* like readbyte() except returns number of bytes in inbuf */
|
|
__GDEF
|
|
{
|
|
if (G.mem_mode ||
|
|
(G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) <= 0)
|
|
return 0;
|
|
G.cur_zipfile_bufstart += INBUFSIZ; /* always starts on a block boundary */
|
|
G.inptr = G.inbuf;
|
|
defer_leftover_input(__G); /* decrements G.csize */
|
|
|
|
#if CRYPT
|
|
if (G.pInfo->encrypted) {
|
|
uch *p;
|
|
int n;
|
|
|
|
for (n = G.incnt, p = G.inptr; n--; p++)
|
|
zdecode(*p);
|
|
}
|
|
#endif /* CRYPT */
|
|
|
|
return G.incnt;
|
|
|
|
} /* end function fillinbuf() */
|
|
|
|
#endif /* USE_ZLIB */
|
|
|
|
|
|
|
|
|
|
|
|
/************************/
|
|
/* Function seek_zipf() */
|
|
/************************/
|
|
|
|
int seek_zipf(__G__ abs_offset)
|
|
__GDEF
|
|
LONGINT abs_offset;
|
|
{
|
|
/*
|
|
* Seek to the block boundary of the block which includes abs_offset,
|
|
* then read block into input buffer and set pointers appropriately.
|
|
* If block is already in the buffer, just set the pointers. This function
|
|
* is used by do_seekable (process.c), extract_or_test_entrylist (extract.c)
|
|
* and do_string (fileio.c). Also, a slightly modified version is embedded
|
|
* within extract_or_test_entrylist (extract.c). readbyte() and readbuf()
|
|
* (fileio.c) are compatible. NOTE THAT abs_offset is intended to be the
|
|
* "proper offset" (i.e., if there were no extra bytes prepended);
|
|
* cur_zipfile_bufstart contains the corrected offset.
|
|
*
|
|
* Since seek_zipf() is never used during decompression, it is safe to
|
|
* use the slide[] buffer for the error message.
|
|
*
|
|
* returns PK error codes:
|
|
* PK_BADERR if effective offset in zipfile is negative
|
|
* PK_EOF if seeking past end of zipfile
|
|
* PK_OK when seek was successful
|
|
*/
|
|
LONGINT request = abs_offset + G.extra_bytes;
|
|
LONGINT inbuf_offset = request % INBUFSIZ;
|
|
LONGINT bufstart = request - inbuf_offset;
|
|
|
|
if (request < 0) {
|
|
Info(slide, 1, ((char *)slide, LoadFarStringSmall(SeekMsg),
|
|
G.zipfn, LoadFarString(ReportMsg)));
|
|
return(PK_BADERR);
|
|
} else if (bufstart != G.cur_zipfile_bufstart) {
|
|
Trace((stderr,
|
|
"fpos_zip: abs_offset = %ld, G.extra_bytes = %ld\n",
|
|
abs_offset, G.extra_bytes));
|
|
#ifdef USE_STRM_INPUT
|
|
fseek(G.zipfd, (LONGINT)bufstart, SEEK_SET);
|
|
G.cur_zipfile_bufstart = ftell(G.zipfd);
|
|
#else /* !USE_STRM_INPUT */
|
|
G.cur_zipfile_bufstart = lseek(G.zipfd, (LONGINT)bufstart, SEEK_SET);
|
|
#endif /* ?USE_STRM_INPUT */
|
|
Trace((stderr,
|
|
" request = %ld, (abs+extra) = %ld, inbuf_offset = %ld\n",
|
|
request, (abs_offset+G.extra_bytes), inbuf_offset));
|
|
Trace((stderr, " bufstart = %ld, cur_zipfile_bufstart = %ld\n",
|
|
bufstart, G.cur_zipfile_bufstart));
|
|
if ((G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) <= 0)
|
|
return(PK_EOF);
|
|
G.incnt -= (int)inbuf_offset;
|
|
G.inptr = G.inbuf + (int)inbuf_offset;
|
|
} else {
|
|
G.incnt += (G.inptr-G.inbuf) - (int)inbuf_offset;
|
|
G.inptr = G.inbuf + (int)inbuf_offset;
|
|
}
|
|
return(PK_OK);
|
|
} /* end function seek_zipf() */
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef VMS /* for VMS use code in vms.c */
|
|
|
|
/********************/
|
|
/* Function flush() */ /* returns PK error codes: */
|
|
/********************/ /* if cflag => always 0; PK_DISK if write error */
|
|
|
|
int flush(__G__ rawbuf, size, unshrink)
|
|
__GDEF
|
|
uch *rawbuf;
|
|
ulg size;
|
|
int unshrink;
|
|
#if (defined(USE_DEFLATE64) && defined(__16BIT__))
|
|
{
|
|
int ret;
|
|
|
|
/* On 16-bit systems (MSDOS, OS/2 1.x), the standard C library functions
|
|
* cannot handle writes of 64k blocks at once. For these systems, the
|
|
* blocks to flush are split into pieces of 32k or less.
|
|
*/
|
|
while (size > 0x8000L) {
|
|
ret = partflush(__G__ rawbuf, 0x8000L, unshrink);
|
|
if (ret != PK_OK)
|
|
return ret;
|
|
size -= 0x8000L;
|
|
rawbuf += (unsigned)0x8000;
|
|
}
|
|
return partflush(__G__ rawbuf, size, unshrink);
|
|
} /* end function flush() */
|
|
|
|
|
|
/************************/
|
|
/* Function partflush() */ /* returns PK error codes: */
|
|
/************************/ /* if cflag => always 0; PK_DISK if write error */
|
|
|
|
static int partflush(__G__ rawbuf, size, unshrink)
|
|
__GDEF
|
|
uch *rawbuf; /* cannot be ZCONST, gets passed to (*G.message)() */
|
|
ulg size;
|
|
int unshrink;
|
|
#endif /* USE_DEFLATE64 && __16BIT__ */
|
|
{
|
|
register uch *p;
|
|
register uch *q;
|
|
uch *transbuf;
|
|
#if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
|
|
ulg transbufsiz;
|
|
#endif
|
|
/* static int didCRlast = FALSE; moved to globals.h */
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Compute the CRC first; if testing or if disk is full, that's it.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
G.crc32val = crc32(G.crc32val, rawbuf, (extent)size);
|
|
|
|
#ifdef DLL
|
|
if ((G.statreportcb != NULL) &&
|
|
(*G.statreportcb)(__G__ UZ_ST_IN_PROGRESS, G.zipfn, G.filename, NULL))
|
|
return IZ_CTRLC; /* cancel operation by user request */
|
|
#endif
|
|
|
|
if (uO.tflag || size == 0L) /* testing or nothing to write: all done */
|
|
return PK_OK;
|
|
|
|
if (G.disk_full)
|
|
return PK_DISK; /* disk already full: ignore rest of file */
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Write the bytes rawbuf[0..size-1] to the output device, first converting
|
|
end-of-lines and ASCII/EBCDIC as needed. If SMALL_MEM or MED_MEM are NOT
|
|
defined, outbuf is assumed to be at least as large as rawbuf and is not
|
|
necessarily checked for overflow.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
if (!G.pInfo->textmode) { /* write raw binary data */
|
|
/* GRR: note that for standard MS-DOS compilers, size argument to
|
|
* fwrite() can never be more than 65534, so WriteError macro will
|
|
* have to be rewritten if size can ever be that large. For now,
|
|
* never more than 32K. Also note that write() returns an int, which
|
|
* doesn't necessarily limit size to 32767 bytes if write() is used
|
|
* on 16-bit systems but does make it more of a pain; however, because
|
|
* at least MSC 5.1 has a lousy implementation of fwrite() (as does
|
|
* DEC Ultrix cc), write() is used anyway.
|
|
*/
|
|
#ifdef DLL
|
|
if (G.redirect_data)
|
|
writeToMemory(__G__ rawbuf, (extent)size);
|
|
else
|
|
#endif
|
|
if (!uO.cflag && WriteError(rawbuf, size, G.outfile))
|
|
return disk_error(__G);
|
|
else if (uO.cflag && (*G.message)((zvoid *)&G, rawbuf, size, 0))
|
|
return PK_OK;
|
|
} else { /* textmode: aflag is true */
|
|
if (unshrink) {
|
|
/* rawbuf = outbuf */
|
|
transbuf = G.outbuf2;
|
|
#if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
|
|
transbufsiz = TRANSBUFSIZ;
|
|
#endif
|
|
} else {
|
|
/* rawbuf = slide */
|
|
transbuf = G.outbuf;
|
|
#if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
|
|
transbufsiz = OUTBUFSIZ;
|
|
Trace((stderr, "\ntransbufsiz = OUTBUFSIZ = %u\n",
|
|
(unsigned)OUTBUFSIZ));
|
|
#endif
|
|
}
|
|
if (G.newfile) {
|
|
#ifdef VMS_TEXT_CONV
|
|
if (G.pInfo->hostnum == VMS_ && G.extra_field &&
|
|
is_vms_varlen_txt(__G__ G.extra_field,
|
|
G.lrec.extra_field_length))
|
|
G.VMS_line_state = 0; /* 0: ready to read line length */
|
|
else
|
|
G.VMS_line_state = -1; /* -1: don't treat as VMS text */
|
|
#endif
|
|
G.didCRlast = FALSE; /* no previous buffers written */
|
|
G.newfile = FALSE;
|
|
}
|
|
|
|
#ifdef VMS_TEXT_CONV
|
|
if (G.VMS_line_state >= 0)
|
|
{
|
|
/* GRR: really want to check for actual VMS extra field, and
|
|
* ideally for variable-length record format */
|
|
/*
|
|
printf("\n>>>>>> GRR: file is VMS text and has an extra field\n");
|
|
*/
|
|
|
|
p = rawbuf;
|
|
q = transbuf;
|
|
while (p < rawbuf+(unsigned)size) {
|
|
switch (G.VMS_line_state) {
|
|
|
|
/* 0: ready to read line length */
|
|
case 0:
|
|
G.VMS_line_length = 0;
|
|
if (p == rawbuf+(unsigned)size-1) { /* last char */
|
|
G.VMS_line_length = (unsigned)(*p++);
|
|
G.VMS_line_state = 1;
|
|
} else {
|
|
G.VMS_line_length = makeword(p);
|
|
p += 2;
|
|
G.VMS_line_state = 2;
|
|
}
|
|
G.VMS_line_pad =
|
|
((G.VMS_line_length & 1) != 0); /* odd */
|
|
break;
|
|
|
|
/* 1: read one byte of length, need second */
|
|
case 1:
|
|
G.VMS_line_length += ((unsigned)(*p++) << 8);
|
|
G.VMS_line_state = 2;
|
|
break;
|
|
|
|
/* 2: ready to read VMS_line_length chars */
|
|
case 2:
|
|
{
|
|
extent remaining = rawbuf+(unsigned)size-p;
|
|
extent outroom;
|
|
|
|
if (G.VMS_line_length < remaining) {
|
|
remaining = G.VMS_line_length;
|
|
G.VMS_line_state = 3;
|
|
}
|
|
|
|
outroom = transbuf+(unsigned)transbufsiz-q;
|
|
if (remaining >= outroom) {
|
|
remaining -= outroom;
|
|
for (;outroom > 0; p++, outroom--)
|
|
*q++ = native(*p);
|
|
#ifdef DLL
|
|
if (G.redirect_data)
|
|
writeToMemory(__G__ transbuf,
|
|
(extent)(q-transbuf));
|
|
else
|
|
#endif
|
|
if (!uO.cflag && WriteError(transbuf,
|
|
(extent)(q-transbuf), G.outfile))
|
|
return disk_error(__G);
|
|
else if (uO.cflag && (*G.message)((zvoid *)&G,
|
|
transbuf, (ulg)(q-transbuf), 0))
|
|
return PK_OK;
|
|
q = transbuf;
|
|
/* fall through to normal case */
|
|
}
|
|
G.VMS_line_length -= remaining;
|
|
for (;remaining > 0; p++, remaining--)
|
|
*q++ = native(*p);
|
|
}
|
|
break;
|
|
|
|
/* 3: ready to PutNativeEOL */
|
|
case 3:
|
|
if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
|
|
#ifdef DLL
|
|
if (G.redirect_data)
|
|
writeToMemory(__G__ transbuf,
|
|
(extent)(q-transbuf));
|
|
else
|
|
#endif
|
|
if (!uO.cflag &&
|
|
WriteError(transbuf, (extent)(q-transbuf),
|
|
G.outfile))
|
|
return disk_error(__G);
|
|
else if (uO.cflag && (*G.message)((zvoid *)&G,
|
|
transbuf, (ulg)(q-transbuf), 0))
|
|
return PK_OK;
|
|
q = transbuf;
|
|
}
|
|
PutNativeEOL
|
|
G.VMS_line_state = G.VMS_line_pad ? 4 : 0;
|
|
break;
|
|
|
|
/* 4: ready to read pad byte */
|
|
case 4:
|
|
++p;
|
|
G.VMS_line_state = 0;
|
|
break;
|
|
}
|
|
} /* end while */
|
|
|
|
} else
|
|
#endif /* VMS_TEXT_CONV */
|
|
|
|
/*-----------------------------------------------------------------------
|
|
Algorithm: CR/LF => native; lone CR => native; lone LF => native.
|
|
This routine is only for non-raw-VMS, non-raw-VM/CMS files (i.e.,
|
|
stream-oriented files, not record-oriented).
|
|
-----------------------------------------------------------------------*/
|
|
|
|
/* else not VMS text */ {
|
|
p = rawbuf;
|
|
if (*p == LF && G.didCRlast)
|
|
++p;
|
|
G.didCRlast = FALSE;
|
|
for (q = transbuf; p < rawbuf+(unsigned)size; ++p) {
|
|
if (*p == CR) { /* lone CR or CR/LF: treat as EOL */
|
|
PutNativeEOL
|
|
if (p == rawbuf+(unsigned)size-1) /* last char in buffer */
|
|
G.didCRlast = TRUE;
|
|
else if (p[1] == LF) /* get rid of accompanying LF */
|
|
++p;
|
|
} else if (*p == LF) /* lone LF */
|
|
PutNativeEOL
|
|
else
|
|
#ifndef DOS_FLX_OS2_W32
|
|
if (*p != CTRLZ) /* lose all ^Z's */
|
|
#endif
|
|
*q++ = native(*p);
|
|
|
|
#if (defined(SMALL_MEM) || defined(MED_MEM))
|
|
# if (lenEOL == 1) /* don't check unshrink: both buffers small but equal */
|
|
if (!unshrink)
|
|
# endif
|
|
/* check for danger of buffer overflow and flush */
|
|
if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
|
|
Trace((stderr,
|
|
"p - rawbuf = %u q-transbuf = %u size = %lu\n",
|
|
(unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
|
|
if (!uO.cflag && WriteError(transbuf,
|
|
(extent)(q-transbuf), G.outfile))
|
|
return disk_error(__G);
|
|
else if (uO.cflag && (*G.message)((zvoid *)&G,
|
|
transbuf, (ulg)(q-transbuf), 0))
|
|
return PK_OK;
|
|
q = transbuf;
|
|
continue;
|
|
}
|
|
#endif /* SMALL_MEM || MED_MEM */
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------
|
|
Done translating: write whatever we've got to file (or screen).
|
|
-----------------------------------------------------------------------*/
|
|
|
|
Trace((stderr, "p - rawbuf = %u q-transbuf = %u size = %lu\n",
|
|
(unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
|
|
if (q > transbuf) {
|
|
#ifdef DLL
|
|
if (G.redirect_data)
|
|
writeToMemory(__G__ transbuf, (extent)(q-transbuf));
|
|
else
|
|
#endif
|
|
if (!uO.cflag && WriteError(transbuf, (extent)(q-transbuf),
|
|
G.outfile))
|
|
return disk_error(__G);
|
|
else if (uO.cflag && (*G.message)((zvoid *)&G, transbuf,
|
|
(ulg)(q-transbuf), 0))
|
|
return PK_OK;
|
|
}
|
|
}
|
|
|
|
return PK_OK;
|
|
|
|
} /* end function flush() [resp. partflush() for 16-bit Deflate64 support] */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef VMS_TEXT_CONV
|
|
|
|
/********************************/
|
|
/* Function is_vms_varlen_txt() */
|
|
/********************************/
|
|
|
|
static int is_vms_varlen_txt(__G__ ef_buf, ef_len)
|
|
__GDEF
|
|
uch *ef_buf; /* buffer containing extra field */
|
|
unsigned ef_len; /* total length of extra field */
|
|
{
|
|
unsigned eb_id;
|
|
unsigned eb_len;
|
|
uch *eb_data;
|
|
unsigned eb_datlen;
|
|
#define VMSREC_C_UNDEF 0
|
|
#define VMSREC_C_VAR 2
|
|
uch vms_rectype = VMSREC_C_UNDEF;
|
|
uch vms_fileorg = 0;
|
|
|
|
#define VMSPK_ITEMID 0
|
|
#define VMSPK_ITEMLEN 2
|
|
#define VMSPK_ITEMHEADSZ 4
|
|
|
|
#define VMSATR_C_RECATTR 4
|
|
#define VMS_FABSIG 0x42414656 /* "VFAB" */
|
|
/* offsets of interesting fields in VMS fabdef structure */
|
|
#define VMSFAB_B_RFM 31 /* record format byte */
|
|
#define VMSFAB_B_ORG 29 /* file organization byte */
|
|
|
|
if (ef_len == 0 || ef_buf == NULL)
|
|
return FALSE;
|
|
|
|
while (ef_len >= EB_HEADSIZE) {
|
|
eb_id = makeword(EB_ID + ef_buf);
|
|
eb_len = makeword(EB_LEN + ef_buf);
|
|
|
|
if (eb_len > (ef_len - EB_HEADSIZE)) {
|
|
/* discovered some extra field inconsistency! */
|
|
Trace((stderr,
|
|
"is_vms_varlen_txt: block length %u > rest ef_size %u\n", eb_len,
|
|
ef_len - EB_HEADSIZE));
|
|
break;
|
|
}
|
|
|
|
switch (eb_id) {
|
|
case EF_PKVMS:
|
|
/* The PKVMS e.f. raw data part consists of:
|
|
* a) 4 bytes CRC checksum
|
|
* b) list of uncompressed variable-length data items
|
|
* Each data item is introduced by a fixed header
|
|
* - 2 bytes data type ID
|
|
* - 2 bytes <size> of data
|
|
* - <size> bytes of actual attribute data
|
|
*/
|
|
|
|
/* get pointer to start of data and its total length */
|
|
eb_data = ef_buf+(EB_HEADSIZE+4);
|
|
eb_datlen = eb_len-4;
|
|
|
|
/* test the CRC checksum */
|
|
if (makelong(ef_buf+EB_HEADSIZE) !=
|
|
crc32(CRCVAL_INITIAL, eb_data, (extent)eb_datlen))
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"[Warning: CRC error, discarding PKWARE extra field]\n"));
|
|
/* skip over the data analysis code */
|
|
break;
|
|
}
|
|
|
|
/* scan through the attribute data items */
|
|
while (eb_datlen > 4)
|
|
{
|
|
unsigned fldsize = makeword(&eb_data[VMSPK_ITEMLEN]);
|
|
|
|
/* check the item type word */
|
|
switch (makeword(&eb_data[VMSPK_ITEMID])) {
|
|
case VMSATR_C_RECATTR:
|
|
/* we have found the (currently only) interesting
|
|
* data item */
|
|
if (fldsize >= 1) {
|
|
vms_rectype = eb_data[VMSPK_ITEMHEADSZ] & 15;
|
|
vms_fileorg = eb_data[VMSPK_ITEMHEADSZ] >> 4;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
/* skip to next data item */
|
|
eb_datlen -= fldsize + VMSPK_ITEMHEADSZ;
|
|
eb_data += fldsize + VMSPK_ITEMHEADSZ;
|
|
}
|
|
break;
|
|
|
|
case EF_IZVMS:
|
|
if (makelong(ef_buf+EB_HEADSIZE) == VMS_FABSIG) {
|
|
if ((eb_data = extract_izvms_block(__G__
|
|
ef_buf+EB_HEADSIZE, eb_len,
|
|
&eb_datlen, NULL, 0))
|
|
!= NULL)
|
|
{
|
|
if (eb_datlen >= VMSFAB_B_RFM+1) {
|
|
vms_rectype = eb_data[VMSFAB_B_RFM] & 15;
|
|
vms_fileorg = eb_data[VMSFAB_B_ORG] >> 4;
|
|
}
|
|
free(eb_data);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Skip this extra field block */
|
|
ef_buf += (eb_len + EB_HEADSIZE);
|
|
ef_len -= (eb_len + EB_HEADSIZE);
|
|
}
|
|
|
|
return (vms_rectype == VMSREC_C_VAR);
|
|
|
|
} /* end function is_vms_varlen_txtfile() */
|
|
|
|
#endif /* VMS_TEXT_CONV */
|
|
|
|
|
|
|
|
|
|
/*************************/
|
|
/* Function disk_error() */
|
|
/*************************/
|
|
|
|
static int disk_error(__G)
|
|
__GDEF
|
|
{
|
|
/* OK to use slide[] here because this file is finished regardless */
|
|
Info(slide, 0x4a1, ((char *)slide, LoadFarString(DiskFullQuery),
|
|
FnFilter1(G.filename)));
|
|
|
|
#ifndef WINDLL
|
|
fgets(G.answerbuf, 9, stdin);
|
|
if (*G.answerbuf == 'y') /* stop writing to this file */
|
|
G.disk_full = 1; /* (outfile bad?), but new OK */
|
|
else
|
|
#endif
|
|
G.disk_full = 2; /* no: exit program */
|
|
|
|
return PK_DISK;
|
|
|
|
} /* end function disk_error() */
|
|
|
|
#endif /* !VMS */
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************/
|
|
/* Function UzpMessagePrnt() */
|
|
/*****************************/
|
|
|
|
int UZ_EXP UzpMessagePrnt(pG, buf, size, flag)
|
|
zvoid *pG; /* globals struct: always passed */
|
|
uch *buf; /* preformatted string to be printed */
|
|
ulg size; /* length of string (may include nulls) */
|
|
int flag; /* flag bits */
|
|
{
|
|
/* IMPORTANT NOTE:
|
|
* The name of the first parameter of UzpMessagePrnt(), which passes
|
|
* the "Uz_Globs" address, >>> MUST <<< be identical to the string
|
|
* expansion of the __G__ macro in the REENTRANT case (see globals.h).
|
|
* This name identity is mandatory for the LoadFarString() macro
|
|
* (in the SMALL_MEM case) !!!
|
|
*/
|
|
int error;
|
|
uch *q=buf, *endbuf=buf+(unsigned)size;
|
|
#ifdef MORE
|
|
uch *p=buf;
|
|
#if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
|
|
int islinefeed = FALSE;
|
|
#endif
|
|
#endif
|
|
FILE *outfp;
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
These tests are here to allow fine-tuning of UnZip's output messages,
|
|
but none of them will do anything without setting the appropriate bit
|
|
in the flag argument of every Info() statement which is to be turned
|
|
*off*. That is, all messages are currently turned on for all ports.
|
|
To turn off *all* messages, use the UzpMessageNull() function instead
|
|
of this one.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
#if (defined(OS2) && defined(DLL))
|
|
if (MSG_NO_DLL2(flag)) /* if OS/2 DLL bit is set, do NOT print this msg */
|
|
return 0;
|
|
#endif
|
|
#ifdef WINDLL
|
|
if (MSG_NO_WDLL(flag))
|
|
return 0;
|
|
#endif
|
|
#ifdef WINDLL
|
|
if (MSG_NO_WGUI(flag))
|
|
return 0;
|
|
#endif
|
|
/*
|
|
#ifdef ACORN_GUI
|
|
if (MSG_NO_AGUI(flag))
|
|
return 0;
|
|
#endif
|
|
*/
|
|
#ifdef DLL /* don't display message if data is redirected */
|
|
if (((Uz_Globs *)pG)->redirect_data &&
|
|
!((Uz_Globs *)pG)->redirect_text)
|
|
return 0;
|
|
#endif
|
|
|
|
if (MSG_STDERR(flag) && !((Uz_Globs *)pG)->UzO.tflag)
|
|
outfp = (FILE *)stderr;
|
|
else
|
|
outfp = (FILE *)stdout;
|
|
|
|
#ifdef QUERY_TRNEWLN
|
|
/* some systems require termination of query prompts with '\n' to force
|
|
* immediate display */
|
|
if (MSG_MNEWLN(flag)) { /* assumes writable buffer (e.g., slide[]) */
|
|
*endbuf++ = '\n'; /* with room for one more char at end of buf */
|
|
++size; /* (safe assumption: only used for four */
|
|
} /* short queries in extract.c and fileio.c) */
|
|
#endif
|
|
|
|
if (MSG_TNEWLN(flag)) { /* again assumes writable buffer: fragile... */
|
|
if ((!size && !((Uz_Globs *)pG)->sol) ||
|
|
(size && (endbuf[-1] != '\n')))
|
|
{
|
|
*endbuf++ = '\n';
|
|
++size;
|
|
}
|
|
}
|
|
|
|
#ifdef MORE
|
|
# ifdef SCREENSIZE
|
|
/* room for --More-- and one line of overlap: */
|
|
# if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
|
|
SCREENSIZE(&((Uz_Globs *)pG)->height, &((Uz_Globs *)pG)->width);
|
|
# else
|
|
SCREENSIZE(&((Uz_Globs *)pG)->height, (int *)NULL);
|
|
# endif
|
|
((Uz_Globs *)pG)->height -= 2;
|
|
# else
|
|
/* room for --More-- and one line of overlap: */
|
|
((Uz_Globs *)pG)->height = SCREENLINES - 2;
|
|
# if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
|
|
((Uz_Globs *)pG)->width = SCREENWIDTH;
|
|
# endif
|
|
# endif
|
|
#endif /* MORE */
|
|
|
|
if (MSG_LNEWLN(flag) && !((Uz_Globs *)pG)->sol) {
|
|
/* not at start of line: want newline */
|
|
#ifdef OS2DLL
|
|
if (!((Uz_Globs *)pG)->redirect_text) {
|
|
#endif
|
|
putc('\n', outfp);
|
|
fflush(outfp);
|
|
#ifdef MORE
|
|
if (((Uz_Globs *)pG)->M_flag)
|
|
{
|
|
#if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
|
|
((Uz_Globs *)pG)->chars = 0;
|
|
#endif
|
|
++((Uz_Globs *)pG)->numlines;
|
|
++((Uz_Globs *)pG)->lines;
|
|
if (((Uz_Globs *)pG)->lines >= ((Uz_Globs *)pG)->height)
|
|
(*((Uz_Globs *)pG)->mpause)((zvoid *)pG,
|
|
LoadFarString(MorePrompt), 1);
|
|
}
|
|
#endif /* MORE */
|
|
if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
|
|
!isatty(1) && isatty(2))
|
|
{
|
|
/* error output from testing redirected: also send to stderr */
|
|
putc('\n', stderr);
|
|
fflush(stderr);
|
|
}
|
|
#ifdef OS2DLL
|
|
} else
|
|
REDIRECTC('\n');
|
|
#endif
|
|
((Uz_Globs *)pG)->sol = TRUE;
|
|
}
|
|
|
|
/* put zipfile name, filename and/or error/warning keywords here */
|
|
|
|
#ifdef MORE
|
|
if (((Uz_Globs *)pG)->M_flag
|
|
#ifdef OS2DLL
|
|
&& !((Uz_Globs *)pG)->redirect_text
|
|
#endif
|
|
)
|
|
{
|
|
while (p < endbuf) {
|
|
if (*p == '\n') {
|
|
#if (defined(SCREENWIDTH) && defined(SCREENLWRAP))
|
|
islinefeed = TRUE;
|
|
} else if (SCREENLWRAP) {
|
|
if (*p == '\r') {
|
|
((Uz_Globs *)pG)->chars = 0;
|
|
} else {
|
|
# ifdef TABSIZE
|
|
if (*p == '\t')
|
|
((Uz_Globs *)pG)->chars +=
|
|
(TABSIZE - (((Uz_Globs *)pG)->chars % TABSIZE));
|
|
else
|
|
# endif
|
|
++((Uz_Globs *)pG)->chars;
|
|
|
|
if (((Uz_Globs *)pG)->chars >= ((Uz_Globs *)pG)->width)
|
|
islinefeed = TRUE;
|
|
}
|
|
}
|
|
if (islinefeed) {
|
|
islinefeed = FALSE;
|
|
((Uz_Globs *)pG)->chars = 0;
|
|
#endif /* (SCREENWIDTH && SCREEN_LWRAP) */
|
|
++((Uz_Globs *)pG)->numlines;
|
|
++((Uz_Globs *)pG)->lines;
|
|
if (((Uz_Globs *)pG)->lines >= ((Uz_Globs *)pG)->height)
|
|
{
|
|
if ((error = WriteError(q, p-q+1, outfp)) != 0)
|
|
return error;
|
|
fflush(outfp);
|
|
((Uz_Globs *)pG)->sol = TRUE;
|
|
q = p + 1;
|
|
(*((Uz_Globs *)pG)->mpause)((zvoid *)pG,
|
|
LoadFarString(MorePrompt), 1);
|
|
}
|
|
}
|
|
INCSTR(p);
|
|
} /* end while */
|
|
size = (ulg)(p - q); /* remaining text */
|
|
}
|
|
#endif /* MORE */
|
|
|
|
if (size) {
|
|
#ifdef OS2DLL
|
|
if (!((Uz_Globs *)pG)->redirect_text) {
|
|
#endif
|
|
if ((error = WriteError(q, size, outfp)) != 0)
|
|
return error;
|
|
fflush(outfp);
|
|
if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
|
|
!isatty(1) && isatty(2))
|
|
{
|
|
/* error output from testing redirected: also send to stderr */
|
|
if ((error = WriteError(q, size, stderr)) != 0)
|
|
return error;
|
|
fflush(stderr);
|
|
}
|
|
#ifdef OS2DLL
|
|
} else { /* GRR: this is ugly: hide with macro */
|
|
if ((error = REDIRECTPRINT(q, size)) != 0)
|
|
return error;
|
|
}
|
|
#endif /* OS2DLL */
|
|
((Uz_Globs *)pG)->sol = (endbuf[-1] == '\n');
|
|
}
|
|
return 0;
|
|
|
|
} /* end function UzpMessagePrnt() */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef DLL
|
|
|
|
/*****************************/
|
|
/* Function UzpMessageNull() */ /* convenience routine for no output at all */
|
|
/*****************************/
|
|
|
|
int UZ_EXP UzpMessageNull(pG, buf, size, flag)
|
|
zvoid *pG; /* globals struct: always passed */
|
|
uch *buf; /* preformatted string to be printed */
|
|
ulg size; /* length of string (may include nulls) */
|
|
int flag; /* flag bits */
|
|
{
|
|
return 0;
|
|
|
|
} /* end function UzpMessageNull() */
|
|
|
|
#endif /* DLL */
|
|
|
|
|
|
|
|
|
|
|
|
/***********************/
|
|
/* Function UzpInput() */ /* GRR: this is a placeholder for now */
|
|
/***********************/
|
|
|
|
int UZ_EXP UzpInput(pG, buf, size, flag)
|
|
zvoid *pG; /* globals struct: always passed */
|
|
uch *buf; /* preformatted string to be printed */
|
|
int *size; /* (address of) size of buf and of returned string */
|
|
int flag; /* flag bits (bit 0: no echo) */
|
|
{
|
|
/* tell picky compilers to shut up about "unused variable" warnings */
|
|
pG = pG; buf = buf; flag = flag;
|
|
|
|
*size = 0;
|
|
return 0;
|
|
|
|
} /* end function UzpInput() */
|
|
|
|
|
|
|
|
|
|
|
|
#if (!defined(WINDLL) && !defined(MACOS))
|
|
|
|
/***************************/
|
|
/* Function UzpMorePause() */
|
|
/***************************/
|
|
|
|
void UZ_EXP UzpMorePause(pG, prompt, flag)
|
|
zvoid *pG; /* globals struct: always passed */
|
|
ZCONST char *prompt; /* "--More--" prompt */
|
|
int flag; /* 0 = any char OK; 1 = accept only '\n', ' ', q */
|
|
{
|
|
uch c;
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Print a prompt and wait for the user to press a key, then erase prompt
|
|
if possible.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
if (!((Uz_Globs *)pG)->sol)
|
|
fprintf(stderr, "\n");
|
|
/* numlines may or may not be used: */
|
|
fprintf(stderr, prompt, ((Uz_Globs *)pG)->numlines);
|
|
fflush(stderr);
|
|
if (flag & 1) {
|
|
do {
|
|
c = (uch)FGETCH(0);
|
|
} while (
|
|
#ifdef THEOS
|
|
c != 17 && /* standard QUIT key */
|
|
#endif
|
|
c != '\r' && c != '\n' && c != ' ' && c != 'q' && c != 'Q');
|
|
} else
|
|
c = (uch)FGETCH(0);
|
|
|
|
/* newline was not echoed, so cover up prompt line */
|
|
fprintf(stderr, LoadFarString(HidePrompt));
|
|
fflush(stderr);
|
|
|
|
if (
|
|
#ifdef THEOS
|
|
(c == 17) || /* standard QUIT key */
|
|
#endif
|
|
(ToLower(c) == 'q')) {
|
|
DESTROYGLOBALS();
|
|
EXIT(PK_COOL);
|
|
}
|
|
|
|
((Uz_Globs *)pG)->sol = TRUE;
|
|
|
|
#ifdef MORE
|
|
/* space for another screen, enter for another line. */
|
|
if ((flag & 1) && c == ' ')
|
|
((Uz_Globs *)pG)->lines = 0;
|
|
#endif /* MORE */
|
|
|
|
} /* end function UzpMorePause() */
|
|
|
|
#endif /* !WINDLL && !MACOS */
|
|
|
|
|
|
|
|
|
|
#ifndef WINDLL
|
|
|
|
/**************************/
|
|
/* Function UzpPassword() */
|
|
/**************************/
|
|
|
|
int UZ_EXP UzpPassword (pG, rcnt, pwbuf, size, zfn, efn)
|
|
zvoid *pG; /* pointer to UnZip's internal global vars */
|
|
int *rcnt; /* retry counter */
|
|
char *pwbuf; /* buffer for password */
|
|
int size; /* size of password buffer */
|
|
ZCONST char *zfn; /* name of zip archive */
|
|
ZCONST char *efn; /* name of archive entry being processed */
|
|
{
|
|
#if CRYPT
|
|
int r = IZ_PW_ENTERED;
|
|
char *m;
|
|
char *prompt;
|
|
|
|
#ifndef REENTRANT
|
|
/* tell picky compilers to shut up about "unused variable" warnings */
|
|
pG = pG;
|
|
#endif
|
|
|
|
if (*rcnt == 0) { /* First call for current entry */
|
|
*rcnt = 2;
|
|
if ((prompt = (char *)malloc(2*FILNAMSIZ + 15)) != (char *)NULL) {
|
|
sprintf(prompt, LoadFarString(PasswPrompt),
|
|
FnFilter1(zfn), FnFilter2(efn));
|
|
m = prompt;
|
|
} else
|
|
m = (char *)LoadFarString(PasswPrompt2);
|
|
} else { /* Retry call, previous password was wrong */
|
|
(*rcnt)--;
|
|
prompt = NULL;
|
|
m = (char *)LoadFarString(PasswRetry);
|
|
}
|
|
|
|
m = getp(__G__ m, pwbuf, size);
|
|
if (prompt != (char *)NULL) {
|
|
free(prompt);
|
|
}
|
|
if (m == (char *)NULL) {
|
|
r = IZ_PW_ERROR;
|
|
}
|
|
else if (*pwbuf == '\0') {
|
|
r = IZ_PW_CANCELALL;
|
|
}
|
|
return r;
|
|
|
|
#else /* !CRYPT */
|
|
/* tell picky compilers to shut up about "unused variable" warnings */
|
|
pG = pG; rcnt = rcnt; pwbuf = pwbuf; size = size; zfn = zfn; efn = efn;
|
|
|
|
return IZ_PW_ERROR; /* internal error; function should never get called */
|
|
#endif /* ?CRYPT */
|
|
|
|
} /* end function UzpPassword() */
|
|
|
|
|
|
|
|
|
|
|
|
/**********************/
|
|
/* Function handler() */
|
|
/**********************/
|
|
|
|
void handler(signal) /* upon interrupt, turn on echo and exit cleanly */
|
|
int signal;
|
|
{
|
|
GETGLOBALS();
|
|
|
|
#if !(defined(SIGBUS) || defined(SIGSEGV)) /* add a newline if not at */
|
|
(*G.message)((zvoid *)&G, slide, 0L, 0x41); /* start of line (to stderr; */
|
|
#endif /* slide[] should be safe) */
|
|
|
|
echon();
|
|
|
|
#ifdef SIGBUS
|
|
if (signal == SIGBUS) {
|
|
Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
|
|
"bus error"));
|
|
DESTROYGLOBALS();
|
|
EXIT(PK_BADERR);
|
|
}
|
|
#endif /* SIGBUS */
|
|
|
|
#ifdef SIGSEGV
|
|
if (signal == SIGSEGV) {
|
|
Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
|
|
"segmentation violation"));
|
|
DESTROYGLOBALS();
|
|
EXIT(PK_BADERR);
|
|
}
|
|
#endif /* SIGSEGV */
|
|
|
|
/* probably ctrl-C */
|
|
DESTROYGLOBALS();
|
|
#if defined(AMIGA) && defined(__SASC)
|
|
_abort();
|
|
#endif
|
|
EXIT(IZ_CTRLC); /* was EXIT(0), then EXIT(PK_ERR) */
|
|
}
|
|
|
|
#endif /* !WINDLL */
|
|
|
|
|
|
|
|
|
|
#if (!defined(VMS) && !defined(CMS_MVS))
|
|
#if (!defined(OS2) || defined(TIMESTAMP))
|
|
|
|
#if (!defined(HAVE_MKTIME) || defined(WIN32))
|
|
/* also used in amiga/filedate.c and win32/win32.c */
|
|
ZCONST ush ydays[] =
|
|
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
|
|
#endif
|
|
|
|
/*******************************/
|
|
/* Function dos_to_unix_time() */ /* used for freshening/updating/timestamps */
|
|
/*******************************/
|
|
|
|
time_t dos_to_unix_time(dosdatetime)
|
|
ulg dosdatetime;
|
|
{
|
|
time_t m_time;
|
|
|
|
#ifdef HAVE_MKTIME
|
|
|
|
ZCONST time_t now = time(NULL);
|
|
struct tm *tm;
|
|
# define YRBASE 1900
|
|
|
|
tm = localtime(&now);
|
|
tm->tm_isdst = -1; /* let mktime determine if DST is in effect */
|
|
|
|
/* dissect date */
|
|
tm->tm_year = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
|
|
tm->tm_mon = ((int)(dosdatetime >> 21) & 0x0f) - 1;
|
|
tm->tm_mday = ((int)(dosdatetime >> 16) & 0x1f);
|
|
|
|
/* dissect time */
|
|
tm->tm_hour = (int)((unsigned)dosdatetime >> 11) & 0x1f;
|
|
tm->tm_min = (int)((unsigned)dosdatetime >> 5) & 0x3f;
|
|
tm->tm_sec = (int)((unsigned)dosdatetime << 1) & 0x3e;
|
|
|
|
m_time = mktime(tm);
|
|
NATIVE_TO_TIMET(m_time) /* NOP unless MSC 7.0 or Macintosh */
|
|
TTrace((stderr, " final m_time = %lu\n", (ulg)m_time));
|
|
|
|
#else /* !HAVE_MKTIME */
|
|
|
|
int yr, mo, dy, hh, mm, ss;
|
|
#ifdef TOPS20
|
|
# define YRBASE 1900
|
|
struct tmx *tmx;
|
|
char temp[20];
|
|
#else /* !TOPS20 */
|
|
# define YRBASE 1970
|
|
int leap;
|
|
unsigned days;
|
|
struct tm *tm;
|
|
#if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
|
|
#ifdef WIN32
|
|
TIME_ZONE_INFORMATION tzinfo;
|
|
DWORD res;
|
|
#else /* ! WIN32 */
|
|
#ifndef BSD4_4 /* GRR: change to !defined(MODERN) ? */
|
|
#if (defined(BSD) || defined(MTS) || defined(__GO32__))
|
|
struct timeb tbp;
|
|
#else /* !(BSD || MTS || __GO32__) */
|
|
#ifdef DECLARE_TIMEZONE
|
|
extern time_t timezone;
|
|
#endif
|
|
#endif /* ?(BSD || MTS || __GO32__) */
|
|
#endif /* !BSD4_4 */
|
|
#endif /* ?WIN32 */
|
|
#endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
|
|
#endif /* ?TOPS20 */
|
|
|
|
|
|
/* dissect date */
|
|
yr = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
|
|
mo = ((int)(dosdatetime >> 21) & 0x0f) - 1;
|
|
dy = ((int)(dosdatetime >> 16) & 0x1f) - 1;
|
|
|
|
/* dissect time */
|
|
hh = (int)((unsigned)dosdatetime >> 11) & 0x1f;
|
|
mm = (int)((unsigned)dosdatetime >> 5) & 0x3f;
|
|
ss = (int)((unsigned)dosdatetime & 0x1f) * 2;
|
|
|
|
#ifdef TOPS20
|
|
tmx = (struct tmx *)malloc(sizeof(struct tmx));
|
|
sprintf (temp, "%02d/%02d/%02d %02d:%02d:%02d", mo+1, dy+1, yr, hh, mm, ss);
|
|
time_parse(temp, tmx, (char *)0);
|
|
m_time = time_make(tmx);
|
|
free(tmx);
|
|
|
|
#else /* !TOPS20 */
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Calculate the number of seconds since the epoch, usually 1 January 1970.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
/* leap = # of leap yrs from YRBASE up to but not including current year */
|
|
leap = ((yr + YRBASE - 1) / 4); /* leap year base factor */
|
|
|
|
/* calculate days from BASE to this year and add expired days this year */
|
|
days = (yr * 365) + (leap - 492) + ydays[mo];
|
|
|
|
/* if year is a leap year and month is after February, add another day */
|
|
if ((mo > 1) && ((yr+YRBASE)%4 == 0) && ((yr+YRBASE) != 2100))
|
|
++days; /* OK through 2199 */
|
|
|
|
/* convert date & time to seconds relative to 00:00:00, 01/01/YRBASE */
|
|
m_time = (time_t)(((unsigned long)days + dy) * 86400L +
|
|
(unsigned long)hh * 3600L +
|
|
(unsigned long)(mm * 60 + ss));
|
|
/* - 1; MS-DOS times always rounded up to nearest even second */
|
|
TTrace((stderr, "dos_to_unix_time:\n"));
|
|
TTrace((stderr, " m_time before timezone = %lu\n", (ulg)m_time));
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Adjust for local standard timezone offset.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
#if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
|
|
#ifdef WIN32
|
|
/* account for timezone differences */
|
|
res = GetTimeZoneInformation(&tzinfo);
|
|
if (res != TIME_ZONE_ID_INVALID)
|
|
{
|
|
m_time += 60*(tzinfo.Bias);
|
|
#else /* !WIN32 */
|
|
#if (defined(BSD) || defined(MTS) || defined(__GO32__))
|
|
#ifdef BSD4_4
|
|
if ( (dosdatetime >= DOSTIME_2038_01_18) &&
|
|
(m_time < (time_t)0x70000000L) )
|
|
m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
|
|
if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
|
|
m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
|
|
if ((tm = localtime(&m_time)) != (struct tm *)NULL)
|
|
m_time -= tm->tm_gmtoff; /* sec. EAST of GMT: subtr. */
|
|
#else /* !(BSD4_4 */
|
|
ftime(&tbp); /* get `timezone' */
|
|
m_time += tbp.timezone * 60L; /* seconds WEST of GMT: add */
|
|
#endif /* ?(BSD4_4 || __EMX__) */
|
|
#else /* !(BSD || MTS || __GO32__) */
|
|
/* tzset was already called at start of process_zipfiles() */
|
|
/* tzset(); */ /* set `timezone' variable */
|
|
#if (!defined(__BEOS__) && !defined(__HAIKU__)) /* BeOS DR8 has no timezones... */
|
|
m_time += timezone; /* seconds WEST of GMT: add */
|
|
#endif
|
|
#endif /* ?(BSD || MTS || __GO32__) */
|
|
#endif /* ?WIN32 */
|
|
TTrace((stderr, " m_time after timezone = %lu\n", (ulg)m_time));
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Adjust for local daylight savings (summer) time.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
#ifndef BSD4_4 /* (DST already added to tm_gmtoff, so skip tm_isdst) */
|
|
if ( (dosdatetime >= DOSTIME_2038_01_18) &&
|
|
(m_time < (time_t)0x70000000L) )
|
|
m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
|
|
if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
|
|
m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
|
|
TIMET_TO_NATIVE(m_time) /* NOP unless MSC 7.0 or Macintosh */
|
|
if (((tm = localtime((time_t *)&m_time)) != NULL) && tm->tm_isdst)
|
|
#ifdef WIN32
|
|
m_time += 60L * tzinfo.DaylightBias; /* adjust with DST bias */
|
|
else
|
|
m_time += 60L * tzinfo.StandardBias; /* add StdBias (normally 0) */
|
|
#else
|
|
m_time -= 60L * 60L; /* adjust for daylight savings time */
|
|
#endif
|
|
NATIVE_TO_TIMET(m_time) /* NOP unless MSC 7.0 or Macintosh */
|
|
TTrace((stderr, " m_time after DST = %lu\n", (ulg)m_time));
|
|
#endif /* !BSD4_4 */
|
|
#ifdef WIN32
|
|
}
|
|
#endif
|
|
#endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
|
|
#endif /* ?TOPS20 */
|
|
|
|
#endif /* ?HAVE_MKTIME */
|
|
|
|
if ( (dosdatetime >= DOSTIME_2038_01_18) &&
|
|
(m_time < (time_t)0x70000000L) )
|
|
m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
|
|
if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
|
|
m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
|
|
|
|
return m_time;
|
|
|
|
} /* end function dos_to_unix_time() */
|
|
|
|
#endif /* !OS2 || TIMESTAMP */
|
|
#endif /* !VMS && !CMS_MVS */
|
|
|
|
|
|
|
|
#if (!defined(VMS) && !defined(OS2) && !defined(CMS_MVS))
|
|
|
|
/******************************/
|
|
/* Function check_for_newer() */ /* used for overwriting/freshening/updating */
|
|
/******************************/
|
|
|
|
int check_for_newer(__G__ filename) /* return 1 if existing file is newer */
|
|
__GDEF /* or equal; 0 if older; -1 if doesn't */
|
|
char *filename; /* exist yet */
|
|
{
|
|
time_t existing, archive;
|
|
#ifdef USE_EF_UT_TIME
|
|
iztimes z_utime;
|
|
#endif
|
|
#ifdef AOS_VS
|
|
long dyy, dmm, ddd, dhh, dmin, dss;
|
|
|
|
|
|
dyy = (lrec.last_mod_dos_datetime >> 25) + 1980;
|
|
dmm = (lrec.last_mod_dos_datetime >> 21) & 0x0f;
|
|
ddd = (lrec.last_mod_dos_datetime >> 16) & 0x1f;
|
|
dhh = (lrec.last_mod_dos_datetime >> 11) & 0x1f;
|
|
dmin = (lrec.last_mod_dos_datetime >> 5) & 0x3f;
|
|
dss = (lrec.last_mod_dos_datetime & 0x1f) * 2;
|
|
|
|
/* under AOS/VS, file times can only be set at creation time,
|
|
* with the info in a special DG format. Make sure we can create
|
|
* it here - we delete it later & re-create it, whether or not
|
|
* it exists now.
|
|
*/
|
|
if (!zvs_create(filename, (((ulg)dgdate(dmm, ddd, dyy)) << 16) |
|
|
(dhh*1800L + dmin*30L + dss/2L), -1L, -1L, (char *) -1, -1, -1, -1))
|
|
return DOES_NOT_EXIST;
|
|
#endif /* AOS_VS */
|
|
|
|
Trace((stderr, "check_for_newer: doing stat(%s)\n", FnFilter1(filename)));
|
|
if (SSTAT(filename, &G.statbuf)) {
|
|
Trace((stderr,
|
|
"check_for_newer: stat(%s) returns %d: file does not exist\n",
|
|
FnFilter1(filename), SSTAT(filename, &G.statbuf)));
|
|
#ifdef SYMLINKS
|
|
Trace((stderr, "check_for_newer: doing lstat(%s)\n",
|
|
FnFilter1(filename)));
|
|
/* GRR OPTION: could instead do this test ONLY if G.symlnk is true */
|
|
if (lstat(filename, &G.statbuf) == 0) {
|
|
Trace((stderr,
|
|
"check_for_newer: lstat(%s) returns 0: symlink does exist\n",
|
|
FnFilter1(filename)));
|
|
if (QCOND2 && !IS_OVERWRT_ALL)
|
|
Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
|
|
FnFilter1(filename), " with no real file"));
|
|
return EXISTS_AND_OLDER; /* symlink dates are meaningless */
|
|
}
|
|
#endif /* SYMLINKS */
|
|
return DOES_NOT_EXIST;
|
|
}
|
|
Trace((stderr, "check_for_newer: stat(%s) returns 0: file exists\n",
|
|
FnFilter1(filename)));
|
|
|
|
#ifdef SYMLINKS
|
|
/* GRR OPTION: could instead do this test ONLY if G.symlnk is true */
|
|
if (lstat(filename, &G.statbuf) == 0 && S_ISLNK(G.statbuf.st_mode)) {
|
|
Trace((stderr, "check_for_newer: %s is a symbolic link\n",
|
|
FnFilter1(filename)));
|
|
if (QCOND2 && !IS_OVERWRT_ALL)
|
|
Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
|
|
FnFilter1(filename), ""));
|
|
return EXISTS_AND_OLDER; /* symlink dates are meaningless */
|
|
}
|
|
#endif /* SYMLINKS */
|
|
|
|
NATIVE_TO_TIMET(G.statbuf.st_mtime) /* NOP unless MSC 7.0 or Macintosh */
|
|
|
|
#ifdef USE_EF_UT_TIME
|
|
/* The `Unix extra field mtime' should be used for comparison with the
|
|
* time stamp of the existing file >>>ONLY<<< when the EF info is also
|
|
* used to set the modification time of the extracted file.
|
|
*/
|
|
if (G.extra_field &&
|
|
#ifdef IZ_CHECK_TZ
|
|
G.tz_is_valid &&
|
|
#endif
|
|
(ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
|
|
G.lrec.last_mod_dos_datetime, &z_utime, NULL)
|
|
& EB_UT_FL_MTIME))
|
|
{
|
|
TTrace((stderr, "check_for_newer: using Unix extra field mtime\n"));
|
|
existing = G.statbuf.st_mtime;
|
|
archive = z_utime.mtime;
|
|
} else {
|
|
/* round up existing filetime to nearest 2 seconds for comparison,
|
|
* but saturate in case of arithmetic overflow
|
|
*/
|
|
existing = ((G.statbuf.st_mtime & 1) &&
|
|
(G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
|
|
G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
|
|
archive = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
|
|
}
|
|
#else /* !USE_EF_UT_TIME */
|
|
/* round up existing filetime to nearest 2 seconds for comparison,
|
|
* but saturate in case of arithmetic overflow
|
|
*/
|
|
existing = ((G.statbuf.st_mtime & 1) &&
|
|
(G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
|
|
G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
|
|
archive = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
|
|
#endif /* ?USE_EF_UT_TIME */
|
|
|
|
TTrace((stderr, "check_for_newer: existing %lu, archive %lu, e-a %ld\n",
|
|
(ulg)existing, (ulg)archive, (long)(existing-archive)));
|
|
|
|
return (existing >= archive);
|
|
|
|
} /* end function check_for_newer() */
|
|
|
|
#endif /* !VMS && !OS2 && !CMS_MVS */
|
|
|
|
|
|
|
|
|
|
|
|
/************************/
|
|
/* Function do_string() */
|
|
/************************/
|
|
|
|
int do_string(__G__ length, option) /* return PK-type error code */
|
|
__GDEF
|
|
unsigned int length; /* without prototype, ush converted to this */
|
|
int option;
|
|
{
|
|
unsigned comment_bytes_left;
|
|
unsigned int block_len;
|
|
int error=PK_OK;
|
|
#ifdef AMIGA
|
|
char tmp_fnote[2 * AMIGA_FILENOTELEN]; /* extra room for squozen chars */
|
|
#endif
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
This function processes arbitrary-length (well, usually) strings. Four
|
|
major options are allowed: SKIP, wherein the string is skipped (pretty
|
|
logical, eh?); DISPLAY, wherein the string is printed to standard output
|
|
after undergoing any necessary or unnecessary character conversions;
|
|
DS_FN, wherein the string is put into the filename[] array after under-
|
|
going appropriate conversions (including case-conversion, if that is
|
|
indicated: see the global variable pInfo->lcflag); and EXTRA_FIELD,
|
|
wherein the `string' is assumed to be an extra field and is copied to
|
|
the (freshly malloced) buffer G.extra_field. The third option should
|
|
be OK since filename is dimensioned at 1025, but we check anyway.
|
|
|
|
The string, by the way, is assumed to start at the current file-pointer
|
|
position; its length is given by 'length'. So start off by checking the
|
|
length of the string: if zero, we're already done.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
if (!length)
|
|
return PK_COOL;
|
|
|
|
switch (option) {
|
|
|
|
#if (defined(SFX) && defined(CHEAP_SFX_AUTORUN))
|
|
/*
|
|
* Special case: See if the comment begins with an autorun command line.
|
|
* Save that and display (or skip) the remainder.
|
|
*/
|
|
|
|
case CHECK_AUTORUN:
|
|
case CHECK_AUTORUN_Q:
|
|
comment_bytes_left = length;
|
|
if (length >= 10)
|
|
{
|
|
block_len = readbuf(__G__ (char *)G.outbuf, 10);
|
|
if (block_len == 0)
|
|
return PK_EOF;
|
|
comment_bytes_left -= block_len;
|
|
G.outbuf[block_len] = '\0';
|
|
if (!strcmp((char *)G.outbuf, "$AUTORUN$>")) {
|
|
char *eol;
|
|
length -= 10;
|
|
block_len = readbuf(__G__ G.autorun_command,
|
|
MIN(length, sizeof(G.autorun_command)-1));
|
|
if (block_len == 0)
|
|
return PK_EOF;
|
|
comment_bytes_left -= block_len;
|
|
G.autorun_command[block_len] = '\0';
|
|
A_TO_N(G.autorun_command);
|
|
eol = strchr(G.autorun_command, '\n');
|
|
if (!eol)
|
|
eol = G.autorun_command + strlen(G.autorun_command) - 1;
|
|
length -= eol + 1 - G.autorun_command;
|
|
while (eol >= G.autorun_command && isspace(*eol))
|
|
*eol-- = '\0';
|
|
#ifdef WIN32
|
|
/* Win9x console always uses OEM character coding, and
|
|
WinNT console is set to OEM charset by default, too */
|
|
INTERN_TO_OEM(G.autorun_command, G.autorun_command);
|
|
#endif /* WIN32 */
|
|
}
|
|
}
|
|
if (option == CHECK_AUTORUN_Q) /* don't display the remainder */
|
|
length = 0;
|
|
/* seek to beginning of remaining part of comment -- rewind if */
|
|
/* displaying entire comment, or skip to end if discarding it */
|
|
seek_zipf(__G__ G.cur_zipfile_bufstart - G.extra_bytes +
|
|
(G.inptr - G.inbuf) + comment_bytes_left - length);
|
|
if (!length)
|
|
break;
|
|
/* FALL THROUGH... */
|
|
#endif /* SFX && CHEAP_SFX_AUTORUN */
|
|
|
|
/*
|
|
* First normal case: print string on standard output. First set loop
|
|
* variables, then loop through the comment in chunks of OUTBUFSIZ bytes,
|
|
* converting formats and printing as we go. The second half of the
|
|
* loop conditional was added because the file might be truncated, in
|
|
* which case comment_bytes_left will remain at some non-zero value for
|
|
* all time. outbuf and slide are used as scratch buffers because they
|
|
* are available (we should be either before or in between any file pro-
|
|
* cessing).
|
|
*/
|
|
|
|
case DISPLAY:
|
|
case DISPL_8:
|
|
comment_bytes_left = length;
|
|
block_len = OUTBUFSIZ; /* for the while statement, first time */
|
|
while (comment_bytes_left > 0 && block_len > 0) {
|
|
register uch *p = G.outbuf;
|
|
register uch *q = G.outbuf;
|
|
|
|
if ((block_len = readbuf(__G__ (char *)G.outbuf,
|
|
MIN((unsigned)OUTBUFSIZ, comment_bytes_left))) == 0)
|
|
return PK_EOF;
|
|
comment_bytes_left -= block_len;
|
|
|
|
/* this is why we allocated an extra byte for outbuf: terminate
|
|
* with zero (ASCIIZ) */
|
|
G.outbuf[block_len] = '\0';
|
|
|
|
/* remove all ASCII carriage returns from comment before printing
|
|
* (since used before A_TO_N(), check for CR instead of '\r')
|
|
*/
|
|
while (*p) {
|
|
while (*p == CR)
|
|
++p;
|
|
*q++ = *p++;
|
|
}
|
|
/* could check whether (p - outbuf) == block_len here */
|
|
*q = '\0';
|
|
|
|
if (option == DISPL_8) {
|
|
/* translate the text coded in the entry's host-dependent
|
|
"extended ASCII" charset into the compiler's (system's)
|
|
internal text code page */
|
|
Ext_ASCII_TO_Native((char *)G.outbuf, G.pInfo->hostnum,
|
|
G.pInfo->hostver, G.pInfo->HasUxAtt,
|
|
FALSE);
|
|
#ifdef WINDLL
|
|
/* translate to ANSI (RTL internal codepage may be OEM) */
|
|
INTERN_TO_ISO((char *)G.outbuf, (char *)G.outbuf);
|
|
#else /* !WINDLL */
|
|
#ifdef WIN32
|
|
/* Win9x console always uses OEM character coding, and
|
|
WinNT console is set to OEM charset by default, too */
|
|
INTERN_TO_OEM((char *)G.outbuf, (char *)G.outbuf);
|
|
#endif /* WIN32 */
|
|
#endif /* ?WINDLL */
|
|
} else {
|
|
A_TO_N(G.outbuf); /* translate string to native */
|
|
}
|
|
|
|
#ifdef WINDLL
|
|
/* ran out of local mem -- had to cheat */
|
|
win_fprintf((zvoid *)&G, stdout, length, (char *)G.outbuf);
|
|
win_fprintf((zvoid *)&G, stdout, 2, (char *)"\n\n");
|
|
#else /* !WINDLL */
|
|
#ifdef NOANSIFILT /* GRR: can ANSI be used with EBCDIC? */
|
|
(*G.message)((zvoid *)&G, G.outbuf, (ulg)(q-G.outbuf), 0);
|
|
#else /* ASCII, filter out ANSI escape sequences and handle ^S (pause) */
|
|
p = G.outbuf - 1;
|
|
q = slide;
|
|
while (*++p) {
|
|
int pause = FALSE;
|
|
|
|
if (*p == 0x1B) { /* ASCII escape char */
|
|
*q++ = '^';
|
|
*q++ = '[';
|
|
} else if (*p == 0x13) { /* ASCII ^S (pause) */
|
|
pause = TRUE;
|
|
if (p[1] == LF) /* ASCII LF */
|
|
*q++ = *++p;
|
|
else if (p[1] == CR && p[2] == LF) { /* ASCII CR LF */
|
|
*q++ = *++p;
|
|
*q++ = *++p;
|
|
}
|
|
} else
|
|
*q++ = *p;
|
|
if ((unsigned)(q-slide) > WSIZE-3 || pause) { /* flush */
|
|
(*G.message)((zvoid *)&G, slide, (ulg)(q-slide), 0);
|
|
q = slide;
|
|
if (pause && G.extract_flag) /* don't pause for list/test */
|
|
(*G.mpause)((zvoid *)&G, LoadFarString(QuitPrompt), 0);
|
|
}
|
|
}
|
|
(*G.message)((zvoid *)&G, slide, (ulg)(q-slide), 0);
|
|
#endif /* ?NOANSIFILT */
|
|
#endif /* ?WINDLL */
|
|
}
|
|
/* add '\n' if not at start of line */
|
|
(*G.message)((zvoid *)&G, slide, 0L, 0x40);
|
|
break;
|
|
|
|
/*
|
|
* Second case: read string into filename[] array. The filename should
|
|
* never ever be longer than FILNAMSIZ-1 (1024), but for now we'll check,
|
|
* just to be sure.
|
|
*/
|
|
|
|
case DS_FN:
|
|
case DS_FN_L:
|
|
if (length >= FILNAMSIZ) {
|
|
Info(slide, 0x401, ((char *)slide,
|
|
LoadFarString(FilenameTooLongTrunc)));
|
|
error = PK_WARN;
|
|
/* remember excess length in block_len */
|
|
block_len = length - (FILNAMSIZ - 1);
|
|
length = FILNAMSIZ - 1;
|
|
} else
|
|
/* no excess size */
|
|
block_len = 0;
|
|
if (readbuf(__G__ G.filename, length) == 0)
|
|
return PK_EOF;
|
|
G.filename[length] = '\0'; /* terminate w/zero: ASCIIZ */
|
|
|
|
/* translate the Zip entry filename coded in host-dependent "extended
|
|
ASCII" into the compiler's (system's) internal text code page */
|
|
Ext_ASCII_TO_Native(G.filename, G.pInfo->hostnum, G.pInfo->hostver,
|
|
G.pInfo->HasUxAtt, (option == DS_FN_L));
|
|
|
|
if (G.pInfo->lcflag) /* replace with lowercase filename */
|
|
STRLOWER(G.filename, G.filename);
|
|
|
|
if (G.pInfo->vollabel && length > 8 && G.filename[8] == '.') {
|
|
char *p = G.filename+8;
|
|
while (*p++)
|
|
p[-1] = *p; /* disk label, and 8th char is dot: remove dot */
|
|
}
|
|
|
|
if (!block_len) /* no overflow, we're done here */
|
|
break;
|
|
|
|
/*
|
|
* We truncated the filename, so print what's left and then fall
|
|
* through to the SKIP routine.
|
|
*/
|
|
Info(slide, 0x401, ((char *)slide, "[ %s ]\n", FnFilter1(G.filename)));
|
|
length = block_len; /* SKIP the excess bytes... */
|
|
/* FALL THROUGH... */
|
|
|
|
/*
|
|
* Third case: skip string, adjusting readbuf's internal variables
|
|
* as necessary (and possibly skipping to and reading a new block of
|
|
* data).
|
|
*/
|
|
|
|
case SKIP:
|
|
/* cur_zipfile_bufstart already takes account of extra_bytes, so don't
|
|
* correct for it twice: */
|
|
seek_zipf(__G__ G.cur_zipfile_bufstart - G.extra_bytes +
|
|
(G.inptr-G.inbuf) + length);
|
|
break;
|
|
|
|
/*
|
|
* Fourth case: assume we're at the start of an "extra field"; malloc
|
|
* storage for it and read data into the allocated space.
|
|
*/
|
|
|
|
case EXTRA_FIELD:
|
|
if (G.extra_field != (uch *)NULL)
|
|
free(G.extra_field);
|
|
if ((G.extra_field = (uch *)malloc(length)) == (uch *)NULL) {
|
|
Info(slide, 0x401, ((char *)slide, LoadFarString(ExtraFieldTooLong),
|
|
length));
|
|
/* cur_zipfile_bufstart already takes account of extra_bytes,
|
|
* so don't correct for it twice: */
|
|
seek_zipf(__G__ G.cur_zipfile_bufstart - G.extra_bytes +
|
|
(G.inptr-G.inbuf) + length);
|
|
} else
|
|
if (readbuf(__G__ (char *)G.extra_field, length) == 0)
|
|
return PK_EOF;
|
|
break;
|
|
|
|
#ifdef AMIGA
|
|
/*
|
|
* Fifth case, for the Amiga only: take the comment that would ordinarily
|
|
* be skipped over, and turn it into a 79 character string that will be
|
|
* attached to the file as a "filenote" after it is extracted.
|
|
*/
|
|
|
|
case FILENOTE:
|
|
if ((block_len = readbuf(__G__ tmp_fnote, (unsigned)
|
|
MIN(length, 2 * AMIGA_FILENOTELEN - 1))) == 0)
|
|
return PK_EOF;
|
|
if ((length -= block_len) > 0) /* treat remainder as in case SKIP: */
|
|
seek_zipf(__G__ G.cur_zipfile_bufstart - G.extra_bytes
|
|
+ (G.inptr - G.inbuf) + length);
|
|
/* convert multi-line text into single line with no ctl-chars: */
|
|
tmp_fnote[block_len] = '\0';
|
|
while ((short int) --block_len >= 0)
|
|
if ((unsigned) tmp_fnote[block_len] < ' ')
|
|
if (tmp_fnote[block_len+1] == ' ') /* no excess */
|
|
strcpy(tmp_fnote+block_len, tmp_fnote+block_len+1);
|
|
else
|
|
tmp_fnote[block_len] = ' ';
|
|
tmp_fnote[AMIGA_FILENOTELEN - 1] = '\0';
|
|
if (G.filenotes[G.filenote_slot])
|
|
free(G.filenotes[G.filenote_slot]); /* should not happen */
|
|
G.filenotes[G.filenote_slot] = NULL;
|
|
if (tmp_fnote[0]) {
|
|
if (!(G.filenotes[G.filenote_slot] = malloc(strlen(tmp_fnote)+1)))
|
|
return PK_MEM;
|
|
strcpy(G.filenotes[G.filenote_slot], tmp_fnote);
|
|
}
|
|
break;
|
|
#endif /* AMIGA */
|
|
|
|
} /* end switch (option) */
|
|
|
|
return error;
|
|
|
|
} /* end function do_string() */
|
|
|
|
|
|
|
|
|
|
|
|
/***********************/
|
|
/* Function makeword() */
|
|
/***********************/
|
|
|
|
ush makeword(b)
|
|
ZCONST uch *b;
|
|
{
|
|
/*
|
|
* Convert Intel style 'short' integer to non-Intel non-16-bit
|
|
* host format. This routine also takes care of byte-ordering.
|
|
*/
|
|
return (ush)((b[1] << 8) | b[0]);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************/
|
|
/* Function makelong() */
|
|
/***********************/
|
|
|
|
ulg makelong(sig)
|
|
ZCONST uch *sig;
|
|
{
|
|
/*
|
|
* Convert intel style 'long' variable to non-Intel non-16-bit
|
|
* host format. This routine also takes care of byte-ordering.
|
|
*/
|
|
return (((ulg)sig[3]) << 24)
|
|
+ (((ulg)sig[2]) << 16)
|
|
+ (((ulg)sig[1]) << 8)
|
|
+ ((ulg)sig[0]);
|
|
}
|
|
|
|
|
|
|
|
#if CRYPT
|
|
|
|
#ifdef NEED_STR2ISO
|
|
/**********************/
|
|
/* Function str2iso() */
|
|
/**********************/
|
|
|
|
char *str2iso(dst, src)
|
|
char *dst; /* destination buffer */
|
|
register ZCONST char *src; /* source string */
|
|
{
|
|
#ifdef INTERN_TO_ISO
|
|
INTERN_TO_ISO(src, dst);
|
|
#else
|
|
register uch c;
|
|
register char *dstp = dst;
|
|
|
|
do {
|
|
c = (uch)foreign(*src++);
|
|
*dstp++ = (char)ASCII2ISO(c);
|
|
} while (c != '\0');
|
|
#endif
|
|
|
|
return dst;
|
|
}
|
|
#endif /* NEED_STR2ISO */
|
|
|
|
|
|
#ifdef NEED_STR2OEM
|
|
/**********************/
|
|
/* Function str2oem() */
|
|
/**********************/
|
|
|
|
char *str2oem(dst, src)
|
|
char *dst; /* destination buffer */
|
|
register ZCONST char *src; /* source string */
|
|
{
|
|
#ifdef INTERN_TO_OEM
|
|
INTERN_TO_OEM(src, dst);
|
|
#else
|
|
register uch c;
|
|
register char *dstp = dst;
|
|
|
|
do {
|
|
c = (uch)foreign(*src++);
|
|
*dstp++ = (char)ASCII2OEM(c);
|
|
} while (c != '\0');
|
|
#endif
|
|
|
|
return dst;
|
|
}
|
|
#endif /* NEED_STR2OEM */
|
|
|
|
#endif /* CRYPT */
|
|
|
|
|
|
#ifdef ZMEM /* memset/memcmp/memcpy for systems without either them or */
|
|
/* bzero/bcmp/bcopy */
|
|
/* (no known systems as of 960211) */
|
|
|
|
/*********************/
|
|
/* Function memset() */
|
|
/*********************/
|
|
|
|
zvoid *memset(buf, init, len)
|
|
register zvoid *buf; /* buffer location */
|
|
register int init; /* initializer character */
|
|
register unsigned int len; /* length of the buffer */
|
|
{
|
|
zvoid *start;
|
|
|
|
start = buf;
|
|
while (len--)
|
|
*((char *)buf++) = (char)init;
|
|
return start;
|
|
}
|
|
|
|
|
|
|
|
/*********************/
|
|
/* Function memcmp() */
|
|
/*********************/
|
|
|
|
int memcmp(b1, b2, len)
|
|
register ZCONST zvoid *b1;
|
|
register ZCONST zvoid *b2;
|
|
register unsigned int len;
|
|
{
|
|
register int c;
|
|
|
|
if (len > 0) do {
|
|
if ((c = (int)(*((ZCONST unsigned char *)b1)++) -
|
|
(int)(*((ZCONST unsigned char *)b2)++)) != 0)
|
|
return c;
|
|
} while (--len > 0)
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*********************/
|
|
/* Function memcpy() */
|
|
/*********************/
|
|
|
|
zvoid *memcpy(dst, src, len)
|
|
register zvoid *dst;
|
|
register ZCONST zvoid *src;
|
|
register unsigned int len;
|
|
{
|
|
zvoid *start;
|
|
|
|
start = dst;
|
|
while (len-- > 0)
|
|
*((char *)dst)++ = *((ZCONST char *)src)++;
|
|
return start;
|
|
}
|
|
|
|
#endif /* ZMEM */
|
|
|
|
|
|
|
|
|
|
#ifdef NO_STRNICMP
|
|
|
|
/************************/
|
|
/* Function zstrnicmp() */
|
|
/************************/
|
|
|
|
int zstrnicmp(s1, s2, n)
|
|
register ZCONST char *s1, *s2;
|
|
register unsigned n;
|
|
{
|
|
for (; n > 0; --n, ++s1, ++s2) {
|
|
|
|
if (ToLower(*s1) != ToLower(*s2))
|
|
/* test includes early termination of one string */
|
|
return (ToLower(*s1) < ToLower(*s2))? -1 : 1;
|
|
|
|
if (*s1 == '\0') /* both strings terminate early */
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif /* NO_STRNICMP */
|
|
|
|
|
|
|
|
|
|
#ifdef REGULUS /* returns the inode number on success(!)...argh argh argh */
|
|
# undef stat
|
|
|
|
/********************/
|
|
/* Function zstat() */
|
|
/********************/
|
|
|
|
int zstat(p, s)
|
|
ZCONST char *p;
|
|
struct stat *s;
|
|
{
|
|
return (stat((char *)p,s) >= 0? 0 : (-1));
|
|
}
|
|
|
|
#endif /* REGULUS */
|
|
|
|
|
|
|
|
|
|
#ifdef _MBCS
|
|
|
|
/* DBCS support for Info-ZIP's zip (mainly for japanese (-: )
|
|
* by Yoshioka Tsuneo (QWF00133@nifty.ne.jp,tsuneo-y@is.aist-nara.ac.jp)
|
|
* This code is public domain! Date: 1998/12/20
|
|
*/
|
|
|
|
/************************/
|
|
/* Function plastchar() */
|
|
/************************/
|
|
|
|
char *plastchar(ptr, len)
|
|
ZCONST char *ptr;
|
|
extent len;
|
|
{
|
|
unsigned clen;
|
|
ZCONST char *oldptr = ptr;
|
|
while(*ptr != '\0' && len > 0){
|
|
oldptr = ptr;
|
|
clen = CLEN(ptr);
|
|
ptr += clen;
|
|
len -= clen;
|
|
}
|
|
return (char *)oldptr;
|
|
}
|
|
|
|
|
|
#ifdef NEED_UZMBSCHR
|
|
/***********************/
|
|
/* Function uzmbschr() */
|
|
/***********************/
|
|
|
|
unsigned char *uzmbschr(str, c)
|
|
ZCONST unsigned char *str;
|
|
unsigned int c;
|
|
{
|
|
while(*str != '\0'){
|
|
if (*str == c) {return (unsigned char *)str;}
|
|
INCSTR(str);
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif /* NEED_UZMBSCHR */
|
|
|
|
|
|
#ifdef NEED_UZMBSRCHR
|
|
/************************/
|
|
/* Function uzmbsrchr() */
|
|
/************************/
|
|
|
|
unsigned char *uzmbsrchr(str, c)
|
|
ZCONST unsigned char *str;
|
|
unsigned int c;
|
|
{
|
|
unsigned char *match = NULL;
|
|
while(*str != '\0'){
|
|
if (*str == c) {match = (unsigned char *)str;}
|
|
INCSTR(str);
|
|
}
|
|
return match;
|
|
}
|
|
#endif /* NEED_UZMBSRCHR */
|
|
#endif /* _MBCS */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef SMALL_MEM
|
|
|
|
/*******************************/
|
|
/* Function fLoadFarString() */ /* (and friends...) */
|
|
/*******************************/
|
|
|
|
char *fLoadFarString(__GPRO__ const char Far *sz)
|
|
{
|
|
(void)zfstrcpy(G.rgchBigBuffer, sz);
|
|
return G.rgchBigBuffer;
|
|
}
|
|
|
|
char *fLoadFarStringSmall(__GPRO__ const char Far *sz)
|
|
{
|
|
(void)zfstrcpy(G.rgchSmallBuffer, sz);
|
|
return G.rgchSmallBuffer;
|
|
}
|
|
|
|
char *fLoadFarStringSmall2(__GPRO__ const char Far *sz)
|
|
{
|
|
(void)zfstrcpy(G.rgchSmallBuffer2, sz);
|
|
return G.rgchSmallBuffer2;
|
|
}
|
|
|
|
|
|
|
|
|
|
#if (!defined(_MSC_VER) || (_MSC_VER < 600))
|
|
/*************************/
|
|
/* Function zfstrcpy() */ /* portable clone of _fstrcpy() */
|
|
/*************************/
|
|
|
|
char Far * Far zfstrcpy(char Far *s1, const char Far *s2)
|
|
{
|
|
char Far *p = s1;
|
|
|
|
while ((*s1++ = *s2++) != '\0');
|
|
return p;
|
|
}
|
|
#endif /* !_MSC_VER || (_MSC_VER < 600) */
|
|
|
|
#endif /* SMALL_MEM */
|