git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/*---------------------------------------------------------------------------
	2
	3	fileio.c
	4
	5	This file contains routines for doing direct but relatively generic input/
	6	output, file-related sorts of things, plus some miscellaneous stuff. Most
	7	of the stuff has to do with opening, closing, reading and/or writing files.
	8
	9	Contains: open_input_file()
	10	open_outfile() (non-VMS, non-AOS/VS, non-CMS_MVS)
	11	undefer_input()
	12	defer_leftover_input()
	13	readbuf()
	14	readbyte()
	15	fillinbuf()
	16	flush() (non-VMS)
	17	disk_error() (non-VMS)
	18	UzpMessagePrnt()
	19	UzpMessageNull() (DLL only)
	20	UzpInput()
	21	UzpMorePause()
	22	UzpPassword() (non-WINDLL)
	23	handler()
	24	dos_to_unix_time() (non-VMS, non-VM/CMS, non-MVS)
	25	check_for_newer() (non-VMS, non-OS/2, non-VM/CMS, non-MVS)
	26	do_string()
	27	makeword()
	28	makelong()
	29	str2iso() (CRYPT && NEED_STR2ISO, only)
	30	str2oem() (CRYPT && NEED_STR2OEM, only)
	31	memset() (ZMEM only)
	32	memcpy() (ZMEM only)
	33	zstrnicmp()
	34	zstat() (REGULUS only)
	35	fLoadFarString() (SMALL_MEM only)
	36	fLoadFarStringSmall() (SMALL_MEM only)
	37	fLoadFarStringSmall2() (SMALL_MEM only)
	38	zfstrcpy() (SMALL_MEM only)
	39
	40	---------------------------------------------------------------------------*/
	41
	42
	43	#define FILEIO_C
	44	#define UNZIP_INTERNAL
	45	#include "unzip.h"
	46	#ifdef WINDLL
	47	# include "windll/windll.h"
	48	# include <setjmp.h>
	49	#endif
	50	#include "crypt.h"
	51	#include "ttyio.h"
	52
	53	/* setup of codepage conversion for decryption passwords */
	54	#if CRYPT
	55	# if (defined(CRYP_USES_ISO2OEM) && !defined(IZ_ISO2OEM_ARRAY))
	56	# define IZ_ISO2OEM_ARRAY /* pull in iso2oem[] table */
	57	# endif
	58	# if (defined(CRYP_USES_OEM2ISO) && !defined(IZ_OEM2ISO_ARRAY))
	59	# define IZ_OEM2ISO_ARRAY /* pull in oem2iso[] table */
	60	# endif
	61	#endif
	62	#include "ebcdic.h" /* definition/initialization of ebcdic[] */
	63
	64
	65	/*
	66	Note: Under Windows, the maximum size of the buffer that can be used
	67	with any of the *printf calls is 16,384, so win_fprintf was used to
	68	feed the fprintf clone no more than 16K chunks at a time. This should
	69	be valid for anything up to 64K (and probably beyond, assuming your
	70	buffers are that big).
	71	*/
	72	#ifdef WINDLL
	73	# define WriteError(buf,len,strm) \
	74	(win_fprintf(pG, strm, (extent)len, (char far *)buf) != (int)(len))
	75	#else /* !WINDLL */
	76	# ifdef USE_FWRITE
	77	# define WriteError(buf,len,strm) \
	78	((extent)fwrite((char *)(buf),1,(extent)(len),strm) != (extent)(len))
	79	# else
	80	# define WriteError(buf,len,strm) \
	81	((extent)write(fileno(strm),(char *)(buf),(extent)(len)) != (extent)(len))
	82	# endif
	83	#endif /* ?WINDLL */
	84
	85	static int disk_error OF((__GPRO));
	86
	87
	88	/****************************/
	89	/* Strings used in fileio.c */
	90	/****************************/
	91
	92	#if (defined(UNIX) \|\| defined(DOS_FLX_OS2_W32) \|\| defined(__BEOS__))
	93	static ZCONST char Far CannotDeleteOldFile[] =
	94	"error: cannot delete old %s\n";
	95	#ifdef UNIXBACKUP
	96	static ZCONST char Far CannotRenameOldFile[] =
	97	"error: cannot rename old %s\n";
	98	static ZCONST char Far BackupSuffix[] = "~";
	99	#endif
	100	#endif /* UNIX \|\| DOS_FLX_OS2_W32 \|\| __BEOS__ */
	101
	102	static ZCONST char Far CannotOpenZipfile[] =
	103	"error: cannot open zipfile [ %s ]\n";
	104	#if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
	105	static ZCONST char Far CannotCreateFile[] = "error: cannot create %s\n";
	106	#endif
	107	#ifdef NOVELL_BUG_FAILSAFE
	108	static ZCONST char Far NovellBug[] =
	109	"error: %s: stat() says does not exist, but fopen() found anyway\n";
	110	#endif
	111	static ZCONST char Far ReadError[] = "error: zipfile read error\n";
	112	static ZCONST char Far FilenameTooLongTrunc[] =
	113	"warning: filename too long--truncating.\n";
	114	static ZCONST char Far ExtraFieldTooLong[] =
	115	"warning: extra field too long (%d). Ignoring...\n";
	116
	117	#ifdef WINDLL
	118	static ZCONST char Far DiskFullQuery[] =
	119	"%s: write error (disk full?).\n";
	120	#else
	121	static ZCONST char Far DiskFullQuery[] =
	122	"%s: write error (disk full?). Continue? (y/n/^C) ";
	123	static ZCONST char Far ZipfileCorrupt[] =
	124	"error: zipfile probably corrupt (%s)\n";
	125	# ifdef SYMLINKS
	126	static ZCONST char Far FileIsSymLink[] =
	127	"%s exists and is a symbolic link%s.\n";
	128	# endif
	129	# ifdef MORE
	130	static ZCONST char Far MorePrompt[] = "--More--(%lu)";
	131	# endif
	132	static ZCONST char Far QuitPrompt[] =
	133	"--- Press `Q' to quit, or any other key to continue ---";
	134	static ZCONST char Far HidePrompt[] = /* "\r \r"; */
	135	"\r \r";
	136	# if CRYPT
	137	# ifdef MACOS
	138	/* SPC: are names on MacOS REALLY so much longer than elsewhere ??? */
	139	static ZCONST char Far PasswPrompt[] = "[%s]\n %s password: ";
	140	# else
	141	static ZCONST char Far PasswPrompt[] = "[%s] %s password: ";
	142	# endif
	143	static ZCONST char Far PasswPrompt2[] = "Enter password: ";
	144	static ZCONST char Far PasswRetry[] = "password incorrect--reenter: ";
	145	# endif /* CRYPT */
	146	#endif /* !WINDLL */
	147
	148
	149
	150
	151
	152	/******************************/
	153	/* Function open_input_file() */
	154	/******************************/
	155
	156	int open_input_file(__G) /* return 1 if open failed */
	157	__GDEF
	158	{
	159	/*
	160	* open the zipfile for reading and in BINARY mode to prevent cr/lf
	161	* translation, which would corrupt the bitstreams
	162	*/
	163
	164	#if (defined(UNIX) \|\| defined(TOPS20) \|\| defined(AOS_VS) \|\| defined(__BEOS__))
	165	G.zipfd = open(G.zipfn, O_RDONLY);
	166	#else /* !(UNIX \|\| TOPS20 \|\| AOS_VS \|\| __BEOS__) */
	167	#ifdef VMS
	168	G.zipfd = open(G.zipfn, O_RDONLY, 0, "ctx=stm");
	169	#else /* !VMS */
	170	#ifdef MACOS
	171	G.zipfd = open(G.zipfn, 0);
	172	#else /* !MACOS */
	173	#ifdef RISCOS
	174	G.zipfd = fopen(G.zipfn, "rb");
	175	#else /* !RISCOS */
	176	#ifdef CMS_MVS
	177	G.zipfd = vmmvs_open_infile(__G);
	178	#else /* !CMS_MVS */
	179	G.zipfd = open(G.zipfn, O_RDONLY \| O_BINARY);
	180	#endif /* ?CMS_MVS */
	181	#endif /* ?RISCOS */
	182	#endif /* ?MACOS */
	183	#endif /* ?VMS */
	184	#endif /* ?(UNIX \|\| TOPS20 \|\| AOS_VS \|\| __BEOS__) */
	185
	186	#ifdef USE_STRM_INPUT
	187	if (G.zipfd == NULL)
	188	#else
	189	/* if (G.zipfd < 0) / / no good for Windows CE port */
	190	if (G.zipfd == -1)
	191	#endif
	192	{
	193	Info(slide, 0x401, ((char *)slide, LoadFarString(CannotOpenZipfile),
	194	G.zipfn));
	195	return 1;
	196	}
	197	return 0;
	198
	199	} /* end function open_input_file() */
	200
	201
	202
	203
	204	#if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
	205
	206	/***************************/
	207	/* Function open_outfile() */
	208	/***************************/
	209
	210	int open_outfile(__G) /* return 1 if fail */
	211	__GDEF
	212	{
	213	#ifdef DLL
	214	if (G.redirect_data)
	215	return (redirect_outfile(__G) == FALSE);
	216	#endif
	217	#ifdef QDOS
	218	QFilename(__G__ G.filename);
	219	#endif
	220	#if (defined(DOS_FLX_OS2_W32) \|\| defined(UNIX) \|\| defined(__BEOS__))
	221	#ifdef BORLAND_STAT_BUG
	222	/* Borland 5.0's stat() barfs if the filename has no extension and the
	223	* file doesn't exist. */
	224	if (access(G.filename, 0) == -1) {
	225	FILE *tmp = fopen(G.filename, "wb+");
	226
	227	/* file doesn't exist, so create a dummy file to keep stat() from
	228	* failing (will be over-written anyway) */
	229	fputc('0', tmp); /* just to have something in the file */
	230	fclose(tmp);
	231	}
	232	#endif /* BORLAND_STAT_BUG */
	233	#ifdef SYMLINKS
	234	if (SSTAT(G.filename, &G.statbuf) == 0 \|\| lstat(G.filename,&G.statbuf) == 0)
	235	#else
	236	if (SSTAT(G.filename, &G.statbuf) == 0)
	237	#endif /* ?SYMLINKS */
	238	{
	239	Trace((stderr, "open_outfile: stat(%s) returns 0: file exists\n",
	240	FnFilter1(G.filename)));
	241	#ifdef UNIXBACKUP
	242	if (uO.B_flag) { /* do backup */
	243	char *tname;
	244	int blen, flen, tlen;
	245
	246	blen = strlen(BackupSuffix);
	247	flen = strlen(G.filename);
	248	tlen = flen + blen + 1;
	249	if (tlen >= FILNAMSIZ) { /* in case name is too long, truncate */
	250	tname = (char *)malloc(FILNAMSIZ);
	251	if (tname == NULL)
	252	return 1; /* in case we run out of space */
	253	tlen = FILNAMSIZ - 1 - blen;
	254	strcpy(tname, G.filename); /* make backup name */
	255	tname[tlen] = '\0';
	256	} else {
	257	tname = (char *)malloc(tlen);
	258	if (tname == NULL)
	259	return 1; /* in case we run out of space */
	260	strcpy(tname, G.filename); /* make backup name */
	261	}
	262	strcpy(tname+flen, BackupSuffix);
	263
	264	/* GRR: should check if backup file exists, apply -n/-o to that */
	265	if (rename(G.filename, tname) < 0) { /* move file */
	266	Info(slide, 0x401, ((char *)slide,
	267	LoadFarString(CannotRenameOldFile), FnFilter1(G.filename)));
	268	free(tname);
	269	return 1;
	270	}
	271	free(tname);
	272	} else
	273	#endif /* UNIXBACKUP */
	274	#ifdef DOS_FLX_OS2_W32
	275	if (!(G.statbuf.st_mode & S_IWRITE)) {
	276	Trace((stderr, "open_outfile: existing file %s is read-only\n",
	277	FnFilter1(G.filename)));
	278	chmod(G.filename, S_IREAD \| S_IWRITE);
	279	Trace((stderr, "open_outfile: %s now writable\n",
	280	FnFilter1(G.filename)));
	281	}
	282	#endif /* DOS_FLX_OS2_W32 */
	283	if (unlink(G.filename) != 0) {
	284	Info(slide, 0x401, ((char *)slide,
	285	LoadFarString(CannotDeleteOldFile), FnFilter1(G.filename)));
	286	return 1;
	287	}
	288	Trace((stderr, "open_outfile: %s now deleted\n",
	289	FnFilter1(G.filename)));
	290	}
	291	#endif /* DOS_FLX_OS2_W32 \|\| UNIX \|\| __BEOS__ */
	292	#ifdef RISCOS
	293	if (SWI_OS_File_7(G.filename,0xDEADDEAD,0xDEADDEAD,G.lrec.ucsize)!=NULL) {
	294	Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
	295	FnFilter1(G.filename)));
	296	return 1;
	297	}
	298	#endif /* RISCOS */
	299	#ifdef TOPS20
	300	char *tfilnam;
	301
	302	if ((tfilnam = (char )malloc(2strlen(G.filename)+1)) == (char *)NULL)
	303	return 1;
	304	strcpy(tfilnam, G.filename);
	305	upper(tfilnam);
	306	enquote(tfilnam);
	307	if ((G.outfile = fopen(tfilnam, FOPW)) == (FILE *)NULL) {
	308	Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
	309	tfilnam));
	310	free(tfilnam);
	311	return 1;
	312	}
	313	free(tfilnam);
	314	#else /* !TOPS20 */
	315	#ifdef MTS
	316	if (uO.aflag)
	317	G.outfile = fopen(G.filename, FOPWT);
	318	else
	319	G.outfile = fopen(G.filename, FOPW);
	320	if (G.outfile == (FILE *)NULL) {
	321	Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
	322	FnFilter1(G.filename)));
	323	return 1;
	324	}
	325	#else /* !MTS */
	326	#ifdef TANDEM
	327	if (SSTAT(G.filename, &G.statbuf) == 0) {
	328	Trace((stderr, "open_outfile: stat(%s) returns 0 (file exists)\n",
	329	FnFilter1(G.filename)));
	330	if (unlink(G.filename) != 0) {
	331	Trace((stderr, "open_outfile: existing file %s is read-only\n",
	332	FnFilter1(G.filename)));
	333	chmod(G.filename, S_IRUSR \| S_IWUSR);
	334	Trace((stderr, "open_outfile: %s now writable\n",
	335	FnFilter1(G.filename)));
	336	if (unlink(G.filename) != 0)
	337	return 1;
	338	}
	339	Trace((stderr, "open_outfile: %s now deleted\n",
	340	FnFilter1(G.filename)));
	341	}
	342	if (G.pInfo->textmode)
	343	G.outfile = fopen(G.filename, FOPWT);
	344	else
	345	G.outfile = fopen(G.filename, FOPW);
	346	if (G.outfile == (FILE *)NULL) {
	347	Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
	348	FnFilter1(G.filename)));
	349	return 1;
	350	}
	351	#else /* !TANDEM */
	352	#ifdef DEBUG
	353	Info(slide, 1, ((char *)slide,
	354	"open_outfile: doing fopen(%s) for reading\n", FnFilter1(G.filename)));
	355	if ((G.outfile = fopen(G.filename, FOPR)) == (FILE *)NULL)
	356	Info(slide, 1, ((char *)slide,
	357	"open_outfile: fopen(%s) for reading failed: does not exist\n",
	358	FnFilter1(G.filename)));
	359	else {
	360	Info(slide, 1, ((char *)slide,
	361	"open_outfile: fopen(%s) for reading succeeded: file exists\n",
	362	FnFilter1(G.filename)));
	363	fclose(G.outfile);
	364	}
	365	#endif /* DEBUG */
	366	#ifdef NOVELL_BUG_FAILSAFE
	367	if (G.dne && ((G.outfile = fopen(G.filename, FOPR)) != (FILE *)NULL)) {
	368	Info(slide, 0x401, ((char *)slide, LoadFarString(NovellBug),
	369	FnFilter1(G.filename)));
	370	fclose(G.outfile);
	371	return 1; /* with "./" fix in checkdir(), should never reach here */
	372	}
	373	#endif /* NOVELL_BUG_FAILSAFE */
	374	Trace((stderr, "open_outfile: doing fopen(%s) for writing\n",
	375	FnFilter1(G.filename)));
	376	if ((G.outfile = fopen(G.filename, FOPW)) == (FILE *)NULL) {
	377	Info(slide, 0x401, ((char *)slide, LoadFarString(CannotCreateFile),
	378	FnFilter1(G.filename)));
	379	return 1;
	380	}
	381	Trace((stderr, "open_outfile: fopen(%s) for writing succeeded\n",
	382	FnFilter1(G.filename)));
	383	#endif /* !TANDEM */
	384	#endif /* !MTS */
	385	#endif /* !TOPS20 */
	386
	387	#ifdef USE_FWRITE
	388	#ifdef DOS_OS2_W32
	389	/* 16-bit MSC: buffer size must be strictly LESS than 32K (WSIZE): bogus */
	390	setbuf(G.outfile, (char )NULL); / make output unbuffered */
	391	#else /* !DOS_OS2_W32 */
	392	#ifndef RISCOS
	393	#ifdef _IOFBF /* make output fully buffered (works just about like write()) */
	394	setvbuf(G.outfile, (char *)slide, _IOFBF, WSIZE);
	395	#else
	396	setbuf(G.outfile, (char *)slide);
	397	#endif
	398	#endif /* !RISCOS */
	399	#endif /* ?DOS_OS2_W32 */
	400	#endif /* USE_FWRITE */
	401	return 0;
	402
	403	} /* end function open_outfile() */
	404
	405	#endif /* !VMS && !AOS_VS && !CMS_MVS && !MACOS */
	406
	407
	408
	409
	410
	411	/*
	412	* These functions allow NEXTBYTE to function without needing two bounds
	413	* checks. Call defer_leftover_input() if you ever have filled G.inbuf
	414	* by some means other than readbyte(), and you then want to start using
	415	* NEXTBYTE. When going back to processing bytes without NEXTBYTE, call
	416	* undefer_input(). For example, extract_or_test_member brackets its
	417	* central section that does the decompression with these two functions.
	418	* If you need to check the number of bytes remaining in the current
	419	* file while using NEXTBYTE, check (G.csize + G.incnt), not G.csize.
	420	*/
	421
	422	/****************************/
	423	/* function undefer_input() */
	424	/****************************/
	425
	426	void undefer_input(__G)
	427	__GDEF
	428	{
	429	if (G.incnt > 0)
	430	G.csize += G.incnt;
	431	if (G.incnt_leftover > 0) {
	432	/* We know that "(G.csize < MAXINT)" so we can cast G.csize to int:
	433	* This condition was checked when G.incnt_leftover was set > 0 in
	434	* defer_leftover_input(), and it is NOT allowed to touch G.csize
	435	* before calling undefer_input() when (G.incnt_leftover > 0)
	436	* (single exception: see read_byte()'s "G.csize <= 0" handling) !!
	437	*/
	438	G.incnt = G.incnt_leftover + (int)G.csize;
	439	G.inptr = G.inptr_leftover - (int)G.csize;
	440	G.incnt_leftover = 0;
	441	} else if (G.incnt < 0)
	442	G.incnt = 0;
	443	} /* end function undefer_input() */
	444
	445
	446
	447
	448
	449	/***********************************/
	450	/* function defer_leftover_input() */
	451	/***********************************/
	452
	453	void defer_leftover_input(__G)
	454	__GDEF
	455	{
	456	if ((long)G.incnt > G.csize) {
	457	/* (G.csize < MAXINT), we can safely cast it to int !! */
	458	if (G.csize < 0L)
	459	G.csize = 0L;
	460	G.inptr_leftover = G.inptr + (int)G.csize;
	461	G.incnt_leftover = G.incnt - (int)G.csize;
	462	G.incnt = (int)G.csize;
	463	} else
	464	G.incnt_leftover = 0;
	465	G.csize -= G.incnt;
	466	} /* end function defer_leftover_input() */
	467
	468
	469
	470
	471
	472	/**********************/
	473	/* Function readbuf() */
	474	/**********************/
	475
	476	unsigned readbuf(__G__ buf, size) /* return number of bytes read into buf */
	477	__GDEF
	478	char *buf;
	479	register unsigned size;
	480	{
	481	register unsigned count;
	482	unsigned n;
	483
	484	n = size;
	485	while (size) {
	486	if (G.incnt <= 0) {
	487	if ((G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) == 0)
	488	return (n-size);
	489	else if (G.incnt < 0) {
	490	/* another hack, but no real harm copying same thing twice */
	491	(G.message)((zvoid )&G,
	492	(uch )LoadFarString(ReadError), / CANNOT use slide */
	493	(ulg)strlen(LoadFarString(ReadError)), 0x401);
	494	return 0; /* discarding some data; better than lock-up */
	495	}
	496	/* buffer ALWAYS starts on a block boundary: */
	497	G.cur_zipfile_bufstart += INBUFSIZ;
	498	G.inptr = G.inbuf;
	499	}
	500	count = MIN(size, (unsigned)G.incnt);
	501	memcpy(buf, G.inptr, count);
	502	buf += count;
	503	G.inptr += count;
	504	G.incnt -= count;
	505	size -= count;
	506	}
	507	return n;
	508
	509	} /* end function readbuf() */
	510
	511
	512
	513
	514
	515	/***********************/
	516	/* Function readbyte() */
	517	/***********************/
	518
	519	int readbyte(__G) /* refill inbuf and return a byte if available, else EOF */
	520	__GDEF
	521	{
	522	if (G.mem_mode)
	523	return EOF;
	524	if (G.csize <= 0) {
	525	G.csize--; /* for tests done after exploding */
	526	G.incnt = 0;
	527	return EOF;
	528	}
	529	if (G.incnt <= 0) {
	530	if ((G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) == 0) {
	531	G.incnt = 0; /* do not allow negative value to affect stuff */
	532	return EOF;
	533	} else if (G.incnt < 0) { /* "fail" (abort, retry, ...) returns this */
	534	/* another hack, but no real harm copying same thing twice */
	535	(G.message)((zvoid )&G,
	536	(uch *)LoadFarString(ReadError),
	537	(ulg)strlen(LoadFarString(ReadError)), 0x401);
	538	echon();
	539	#ifdef WINDLL
	540	longjmp(dll_error_return, 1);
	541	#else
	542	DESTROYGLOBALS()
	543	EXIT(PK_BADERR); /* totally bailing; better than lock-up */
	544	#endif
	545	}
	546	G.cur_zipfile_bufstart += INBUFSIZ; /* always starts on block bndry */
	547	G.inptr = G.inbuf;
	548	defer_leftover_input(__G); /* decrements G.csize */
	549	}
	550
	551	#if CRYPT
	552	if (G.pInfo->encrypted) {
	553	uch *p;
	554	int n;
	555
	556	/* This was previously set to decrypt one byte beyond G.csize, when
	557	* incnt reached that far. GRR said, "but it's required: why?" This
	558	* was a bug in fillinbuf() -- was it also a bug here?
	559	*/
	560	for (n = G.incnt, p = G.inptr; n--; p++)
	561	zdecode(*p);
	562	}
	563	#endif /* CRYPT */
	564
	565	--G.incnt;
	566	return *G.inptr++;
	567
	568	} /* end function readbyte() */
	569
	570
	571
	572
	573
	574	#ifdef USE_ZLIB
	575
	576	/************************/
	577	/* Function fillinbuf() */
	578	/************************/
	579
	580	int fillinbuf(__G) /* like readbyte() except returns number of bytes in inbuf */
	581	__GDEF
	582	{
	583	if (G.mem_mode \|\|
	584	(G.incnt = read(G.zipfd, (char *)G.inbuf, INBUFSIZ)) <= 0)
	585	return 0;
	586	G.cur_zipfile_bufstart += INBUFSIZ; /* always starts on a block boundary */
	587	G.inptr = G.inbuf;
	588	defer_leftover_input(__G); /* decrements G.csize */
	589
	590	#if CRYPT
	591	if (G.pInfo->encrypted) {
	592	uch *p;
	593	int n;
	594
	595	for (n = G.incnt, p = G.inptr; n--; p++)
	596	zdecode(*p);
	597	}
	598	#endif /* CRYPT */
	599
	600	return G.incnt;
	601
	602	} /* end function fillinbuf() */
	603
	604	#endif /* USE_ZLIB */
	605
	606
	607
	608
	609
	610	#ifndef VMS /* for VMS use code in vms.c */
	611
	612	/********************/
	613	/* Function flush() / / returns PK error codes: */
	614	/*******************/ / if cflag => always 0; PK_DISK if write error */
	615
	616	int flush(__G__ rawbuf, size, unshrink)
	617	__GDEF
	618	uch *rawbuf;
	619	ulg size;
	620	int unshrink;
	621	{
	622	register uch p, q;
	623	uch *transbuf;
	624	#if (defined(SMALL_MEM) \|\| defined(MED_MEM) \|\| defined(VMS_TEXT_CONV))
	625	ulg transbufsiz;
	626	#endif
	627	/* static int didCRlast = FALSE; moved to globals.h */
	628
	629
	630	/*---------------------------------------------------------------------------
	631	Compute the CRC first; if testing or if disk is full, that's it.
	632	---------------------------------------------------------------------------*/
	633
	634	G.crc32val = crc32(G.crc32val, rawbuf, (extent)size);
	635
	636	#ifdef DLL
	637	if ((G.statreportcb != NULL) &&
	638	(*G.statreportcb)(__G__ UZ_ST_IN_PROGRESS, G.zipfn, G.filename, NULL))
	639	return IZ_CTRLC; /* cancel operation by user request */
	640	#endif
	641
	642	if (uO.tflag \|\| size == 0L) /* testing or nothing to write: all done */
	643	return PK_OK;
	644
	645	if (G.disk_full)
	646	return PK_DISK; /* disk already full: ignore rest of file */
	647
	648	/*---------------------------------------------------------------------------
	649	Write the bytes rawbuf[0..size-1] to the output device, first converting
	650	end-of-lines and ASCII/EBCDIC as needed. If SMALL_MEM or MED_MEM are NOT
	651	defined, outbuf is assumed to be at least as large as rawbuf and is not
	652	necessarily checked for overflow.
	653	---------------------------------------------------------------------------*/
	654
	655	if (!G.pInfo->textmode) { /* write raw binary data */
	656	/* GRR: note that for standard MS-DOS compilers, size argument to
	657	* fwrite() can never be more than 65534, so WriteError macro will
	658	* have to be rewritten if size can ever be that large. For now,
	659	* never more than 32K. Also note that write() returns an int, which
	660	* doesn't necessarily limit size to 32767 bytes if write() is used
	661	* on 16-bit systems but does make it more of a pain; however, because
	662	* at least MSC 5.1 has a lousy implementation of fwrite() (as does
	663	* DEC Ultrix cc), write() is used anyway.
	664	*/
	665	#ifdef DLL
	666	if (G.redirect_data)
	667	writeToMemory(__G__ rawbuf, size);
	668	else
	669	#endif
	670	if (!uO.cflag && WriteError(rawbuf, size, G.outfile))
	671	return disk_error(__G);
	672	else if (uO.cflag && (G.message)((zvoid )&G, rawbuf, size, 0))
	673	return 0;
	674	} else { /* textmode: aflag is true */
	675	if (unshrink) {
	676	/* rawbuf = outbuf */
	677	transbuf = G.outbuf2;
	678	#if (defined(SMALL_MEM) \|\| defined(MED_MEM) \|\| defined(VMS_TEXT_CONV))
	679	transbufsiz = TRANSBUFSIZ;
	680	#endif
	681	} else {
	682	/* rawbuf = slide */
	683	transbuf = G.outbuf;
	684	#if (defined(SMALL_MEM) \|\| defined(MED_MEM) \|\| defined(VMS_TEXT_CONV))
	685	transbufsiz = OUTBUFSIZ;
	686	Trace((stderr, "\ntransbufsiz = OUTBUFSIZ = %u\n", OUTBUFSIZ));
	687	#endif
	688	}
	689	if (G.newfile) {
	690	#ifdef VMS_TEXT_CONV
	691	/* GRR: really want to check if -aa (or -aaa?) was given... */
	692	if (rawbuf[1]) { /* first line is more than 255 chars long */
	693	Trace((stderr,
	694	"\nfirst line of VMS `text' too long; switching to normal extraction\n"));
	695	G.VMS_line_state = -1; /* -1: don't treat as VMS text */
	696	} else
	697	G.VMS_line_state = 0; /* 0: ready to read line length */
	698	#endif
	699	G.didCRlast = FALSE; /* no previous buffers written */
	700	G.newfile = FALSE;
	701	}
	702
	703	#ifdef VMS_TEXT_CONV
	704	if (G.pInfo->hostnum == VMS_ && G.extra_field && G.VMS_line_state >= 0)
	705	{
	706	/* GRR: really want to check for actual VMS extra field, and
	707	* ideally for variable-length record format */
	708	/*
	709	printf("\n>>>>>> GRR: file is VMS text and has an extra field\n");
	710	*/
	711
	712	p = rawbuf;
	713	q = transbuf;
	714	while(p < rawbuf+(unsigned)size) {
	715	switch (G.VMS_line_state) {
	716
	717	/* 0: ready to read line length */
	718	case 0:
	719	G.VMS_line_length = 0;
	720	G.VMS_line_pad = 0;
	721	if (p == rawbuf+(unsigned)size-1) { /* last char */
	722	G.VMS_line_length = (int)((uch)(*p++));
	723	G.VMS_line_state = 1;
	724	} else {
	725	G.VMS_line_length = makeword(p);
	726	p += 2;
	727	G.VMS_line_state = 2;
	728	}
	729	if (G.VMS_line_length & 1) /* odd */
	730	G.VMS_line_pad = 1;
	731	break;
	732
	733	/* 1: read one byte of length, need second */
	734	case 1:
	735	G.VMS_line_length += ((int)((uch)(*p++)) << 8);
	736	G.VMS_line_state = 2;
	737	break;
	738
	739	/* 2: ready to read VMS_line_length chars */
	740	case 2:
	741	if (G.VMS_line_length < rawbuf+(unsigned)size-p) {
	742	if (G.VMS_line_length >=
	743	transbuf+(unsigned)transbufsiz-q)
	744	{
	745	int outroom = transbuf+(unsigned)transbufsiz-q;
	746
	747	/* GRR: need to change this to q++ = native(p++); loop or something */
	748	memcpy(q, p, outroom);
	749	#ifdef DLL
	750	if (G.redirect_data)
	751	writeToMemory(__G__ transbuf,
	752	(unsigned)outroom);
	753	else
	754	#endif
	755	if (!uO.cflag && WriteError(transbuf,
	756	(unsigned)outroom, G.outfile))
	757	return disk_error(__G);
	758	else if (uO.cflag && (G.message)((zvoid )&G,
	759	transbuf, (ulg)outroom, 0))
	760	return 0;
	761	q = transbuf;
	762	p += outroom;
	763	G.VMS_line_length -= outroom;
	764	/* fall through to normal case */
	765	}
	766	/* GRR: need to change this to q++ = native(p++); loop or something */
	767	memcpy(q, p, G.VMS_line_length);
	768	q += G.VMS_line_length;
	769	p += G.VMS_line_length;
	770	G.VMS_line_length = 0; /* necessary?? */
	771	G.VMS_line_state = 3;
	772
	773	} else { /* remaining input is less than full line */
	774	int remaining = rawbuf+(unsigned)size-p;
	775
	776	if (remaining <
	777	transbuf+(unsigned)transbufsiz-q)
	778	{
	779	int outroom = transbuf+(unsigned)transbufsiz-q;
	780
	781	/* GRR: need to change this to q++ = native(p++); loop or something */
	782	memcpy(q, p, outroom);
	783	#ifdef DLL
	784	if (G.redirect_data)
	785	writeToMemory(__G__ transbuf,
	786	(unsigned)(outroom));
	787	else
	788	#endif
	789	if (!uO.cflag && WriteError(transbuf,
	790	(unsigned)outroom, G.outfile))
	791	return disk_error(__G);
	792	else if (uO.cflag && (G.message)((zvoid )&G,
	793	transbuf, (ulg)outroom, 0))
	794	return 0;
	795	q = transbuf;
	796	p += outroom;
	797	remaining -= outroom;
	798	}
	799	/* GRR: need to change this to q++ = native(p++); loop or something */
	800	memcpy(q, p, remaining);
	801	q += remaining;
	802	p += remaining;
	803	G.VMS_line_length -= remaining;
	804	/* no change in G.VMS_line_state */
	805	}
	806	break;
	807
	808	/* 3: ready to PutNativeEOL */
	809	case 3:
	810	if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
	811	#ifdef DLL
	812	if (G.redirect_data)
	813	writeToMemory(__G__ transbuf,
	814	(unsigned)(q-transbuf));
	815	else
	816	#endif
	817	if (!uO.cflag &&
	818	WriteError(transbuf, (unsigned)(q-transbuf),
	819	G.outfile))
	820	return disk_error(__G);
	821	else if (uO.cflag && (G.message)((zvoid )&G,
	822	transbuf, (ulg)(q-transbuf), 0))
	823	return 0;
	824	q = transbuf;
	825	}
	826	PutNativeEOL
	827	if (G.VMS_line_pad)
	828	if (p < rawbuf+(unsigned)size) {
	829	++p;
	830	G.VMS_line_state = 0;
	831	} else
	832	G.VMS_line_state = 4;
	833	else
	834	G.VMS_line_state = 0;
	835	break;
	836
	837	/* 4: ready to read pad byte */
	838	case 4:
	839	++p;
	840	G.VMS_line_state = 0;
	841	break;
	842	}
	843	} /* end while */
	844
	845	} else
	846	#endif /* VMS_TEXT_CONV */
	847
	848	/*-----------------------------------------------------------------------
	849	Algorithm: CR/LF => native; lone CR => native; lone LF => native.
	850	This routine is only for non-raw-VMS, non-raw-VM/CMS files (i.e.,
	851	stream-oriented files, not record-oriented).
	852	-----------------------------------------------------------------------*/
	853
	854	/* else not VMS text */ {
	855	p = rawbuf;
	856	if (*p == LF && G.didCRlast)
	857	++p;
	858	G.didCRlast = FALSE;
	859	for (q = transbuf; p < rawbuf+(unsigned)size; ++p) {
	860	if (p == CR) { / lone CR or CR/LF: EOL either way */
	861	PutNativeEOL
	862	if (p == rawbuf+(unsigned)size-1) /* last char in buffer */
	863	G.didCRlast = TRUE;
	864	else if (p[1] == LF) /* get rid of accompanying LF */
	865	++p;
	866	} else if (p == LF) / lone LF */
	867	PutNativeEOL
	868	else
	869	#ifndef DOS_FLX_OS2_W32
	870	if (p != CTRLZ) / lose all ^Z's */
	871	#endif
	872	q++ = native(p);
	873
	874	#if (defined(SMALL_MEM) \|\| defined(MED_MEM))
	875	# if (lenEOL == 1) /* don't check unshrink: both buffers small but equal */
	876	if (!unshrink)
	877	# endif
	878	/* check for danger of buffer overflow and flush */
	879	if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
	880	Trace((stderr,
	881	"p - rawbuf = %u q-transbuf = %u size = %lu\n",
	882	(unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
	883	if (!uO.cflag && WriteError(transbuf,
	884	(unsigned)(q-transbuf), G.outfile))
	885	return disk_error(__G);
	886	else if (uO.cflag && (G.message)((zvoid )&G,
	887	transbuf, (ulg)(q-transbuf), 0))
	888	return 0;
	889	q = transbuf;
	890	continue;
	891	}
	892	#endif /* SMALL_MEM \|\| MED_MEM */
	893	}
	894	}
	895
	896	/*-----------------------------------------------------------------------
	897	Done translating: write whatever we've got to file (or screen).
	898	-----------------------------------------------------------------------*/
	899
	900	Trace((stderr, "p - rawbuf = %u q-transbuf = %u size = %lu\n",
	901	(unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
	902	if (q > transbuf) {
	903	#ifdef DLL
	904	if (G.redirect_data)
	905	writeToMemory(__G__ transbuf, (unsigned)(q-transbuf));
	906	else
	907	#endif
	908	if (!uO.cflag && WriteError(transbuf, (unsigned)(q-transbuf),
	909	G.outfile))
	910	return disk_error(__G);
	911	else if (uO.cflag && (G.message)((zvoid )&G, transbuf,
	912	(ulg)(q-transbuf), 0))
	913	return 0;
	914	}
	915	}
	916
	917	return 0;
	918
	919	} /* end function flush() */
	920
	921
	922
	923
	924
	925	/*************************/
	926	/* Function disk_error() */
	927	/*************************/
	928
	929	static int disk_error(__G)
	930	__GDEF
	931	{
	932	/* OK to use slide[] here because this file is finished regardless */
	933	Info(slide, 0x4a1, ((char *)slide, LoadFarString(DiskFullQuery),
	934	FnFilter1(G.filename)));
	935
	936	#ifndef WINDLL
	937	fgets(G.answerbuf, 9, stdin);
	938	if (G.answerbuf == 'y') / stop writing to this file */
	939	G.disk_full = 1; /* (outfile bad?), but new OK */
	940	else
	941	#endif
	942	G.disk_full = 2; /* no: exit program */
	943
	944	return PK_DISK;
	945
	946	} /* end function disk_error() */
	947
	948	#endif /* !VMS */
	949
	950
	951
	952
	953
	954	/*****************************/
	955	/* Function UzpMessagePrnt() */
	956	/*****************************/
	957
	958	int UZ_EXP UzpMessagePrnt(pG, buf, size, flag)
	959	zvoid pG; / globals struct: always passed */
	960	uch buf; / preformatted string to be printed */
	961	ulg size; /* length of string (may include nulls) */
	962	int flag; /* flag bits */
	963	{
	964	/* IMPORTANT NOTE:
	965	* The name of the first parameter of UzpMessagePrnt(), which passes
	966	* the "Uz_Globs" address, >>> MUST <<< be identical to the string
	967	* expansion of the __G__ macro in the REENTRANT case (see globals.h).
	968	* This name identity is mandatory for the LoadFarString() macro
	969	* (in the SMALL_MEM case) !!!
	970	*/
	971	int error;
	972	uch q=buf, endbuf=buf+(unsigned)size;
	973	#ifdef MORE
	974	uch *p=buf-1;
	975	#endif
	976	FILE *outfp;
	977
	978
	979	/*---------------------------------------------------------------------------
	980	These tests are here to allow fine-tuning of UnZip's output messages,
	981	but none of them will do anything without setting the appropriate bit
	982	in the flag argument of every Info() statement which is to be turned
	983	off. That is, all messages are currently turned on for all ports.
	984	To turn off all messages, use the UzpMessageNull() function instead
	985	of this one.
	986	---------------------------------------------------------------------------*/
	987
	988	#if (defined(OS2) && defined(DLL))
	989	if (MSG_NO_DLL2(flag)) /* if OS/2 DLL bit is set, do NOT print this msg */
	990	return 0;
	991	#endif
	992	#ifdef WINDLL
	993	if (MSG_NO_WDLL(flag))
	994	return 0;
	995	#endif
	996	#ifdef WINDLL
	997	if (MSG_NO_WGUI(flag))
	998	return 0;
	999	#endif
	1000	/*
	1001	#ifdef ACORN_GUI
	1002	if (MSG_NO_AGUI(flag))
	1003	return 0;
	1004	#endif
	1005	*/
	1006	#ifdef DLL /* don't display message if data is redirected */
	1007	if (((Uz_Globs *)pG)->redirect_data &&
	1008	!((Uz_Globs *)pG)->redirect_text)
	1009	return 0;
	1010	#endif
	1011
	1012	if (MSG_STDERR(flag) && !((Uz_Globs *)pG)->UzO.tflag)
	1013	outfp = (FILE *)stderr;
	1014	else
	1015	outfp = (FILE *)stdout;
	1016
	1017	#ifdef QUERY_TRNEWLN
	1018	/* some systems require termination of query prompts with '\n' to force
	1019	* immediate display */
	1020	if (MSG_MNEWLN(flag)) { /* assumes writable buffer (e.g., slide[]) */
	1021	endbuf++ = '\n'; / with room for one more char at end of buf */
	1022	++size; /* (safe assumption: only used for four */
	1023	} /* short queries in extract.c and fileio.c) */
	1024	#endif
	1025
	1026	if (MSG_TNEWLN(flag)) { /* again assumes writable buffer: fragile... */
	1027	if ((!size && !((Uz_Globs *)pG)->sol) \|\|
	1028	(size && (endbuf[-1] != '\n')))
	1029	{
	1030	*endbuf++ = '\n';
	1031	++size;
	1032	}
	1033	}
	1034
	1035	#ifdef MORE
	1036	/* room for --More-- and one line of overlap: */
	1037	((Uz_Globs *)pG)->height = SCREENLINES - 2;
	1038	#endif
	1039
	1040	if (MSG_LNEWLN(flag) && !((Uz_Globs *)pG)->sol) {
	1041	/* not at start of line: want newline */
	1042	#ifdef OS2DLL
	1043	if (!((Uz_Globs *)pG)->redirect_text) {
	1044	#endif
	1045	putc('\n', outfp);
	1046	fflush(outfp);
	1047	#ifdef MORE
	1048	if (((Uz_Globs *)pG)->M_flag)
	1049	{
	1050	++((Uz_Globs *)pG)->numlines;
	1051	if (((Uz_Globs *)pG)->numlines %
	1052	((Uz_Globs )pG)->height == 0L) / GRR: fix */
	1053	(((Uz_Globs )pG)->mpause)((zvoid *)pG,
	1054	LoadFarString(MorePrompt), 1);
	1055	}
	1056	#endif /* MORE */
	1057	if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
	1058	!isatty(1) && isatty(2))
	1059	{
	1060	/* error output from testing redirected: also send to stderr */
	1061	putc('\n', stderr);
	1062	fflush(stderr);
	1063	}
	1064	#ifdef OS2DLL
	1065	} else
	1066	REDIRECTC('\n');
	1067	#endif
	1068	((Uz_Globs *)pG)->sol = TRUE;
	1069	}
	1070
	1071	/* put zipfile name, filename and/or error/warning keywords here */
	1072
	1073	#ifdef MORE
	1074	if (((Uz_Globs *)pG)->M_flag
	1075	#ifdef OS2DLL
	1076	&& !((Uz_Globs *)pG)->redirect_text
	1077	#endif
	1078	)
	1079	{
	1080	while (++p < endbuf) {
	1081	if (*p == '\n') {
	1082	++((Uz_Globs *)pG)->numlines;
	1083	if (((Uz_Globs *)pG)->numlines %
	1084	((Uz_Globs )pG)->height == 0L) / GRR: fix */
	1085	{
	1086	if ((error = WriteError(q, p-q+1, outfp)) != 0)
	1087	return error;
	1088	fflush(outfp);
	1089	((Uz_Globs *)pG)->sol = TRUE;
	1090	q = p + 1;
	1091	(((Uz_Globs )pG)->mpause)((zvoid *)pG,
	1092	LoadFarString(MorePrompt), 1);
	1093	}
	1094	}
	1095	} /* end while */
	1096	size = (ulg)(p - q); /* remaining text */
	1097	}
	1098	#endif /* MORE */
	1099
	1100	if (size) {
	1101	#ifdef OS2DLL
	1102	if (!((Uz_Globs *)pG)->redirect_text) {
	1103	#endif
	1104	if ((error = WriteError(q, size, outfp)) != 0)
	1105	return error;
	1106	fflush(outfp);
	1107	if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
	1108	!isatty(1) && isatty(2))
	1109	{
	1110	/* error output from testing redirected: also send to stderr */
	1111	if ((error = WriteError(q, size, stderr)) != 0)
	1112	return error;
	1113	fflush(stderr);
	1114	}
	1115	#ifdef OS2DLL
	1116	} else { /* GRR: this is ugly: hide with macro */
	1117	if ((error = REDIRECTPRINT(q, size)) != 0)
	1118	return error;
	1119	}
	1120	#endif
	1121	((Uz_Globs *)pG)->sol = (endbuf[-1] == '\n');
	1122	}
	1123	return 0;
	1124
	1125	} /* end function UzpMessagePrnt() */
	1126
	1127
	1128
	1129
	1130
	1131	#ifdef DLL
	1132
	1133	/*****************************/
	1134	/* Function UzpMessageNull() / / convenience routine for no output at all */
	1135	/*****************************/
	1136
	1137	int UZ_EXP UzpMessageNull(pG, buf, size, flag)
	1138	zvoid pG; / globals struct: always passed */
	1139	uch buf; / preformatted string to be printed */
	1140	ulg size; /* length of string (may include nulls) */
	1141	int flag; /* flag bits */
	1142	{
	1143	return 0;
	1144
	1145	} /* end function UzpMessageNull() */
	1146
	1147	#endif /* DLL */
	1148
	1149
	1150
	1151
	1152
	1153	/***********************/
	1154	/* Function UzpInput() / / GRR: this is a placeholder for now */
	1155	/***********************/
	1156
	1157	int UZ_EXP UzpInput(pG, buf, size, flag)
	1158	zvoid pG; / globals struct: always passed */
	1159	uch buf; / preformatted string to be printed */
	1160	int size; / (address of) size of buf and of returned string */
	1161	int flag; /* flag bits (bit 0: no echo) */
	1162	{
	1163	/* tell picky compilers to shut up about "unused variable" warnings */
	1164	pG = pG; buf = buf; flag = flag;
	1165
	1166	*size = 0;
	1167	return 0;
	1168
	1169	} /* end function UzpInput() */
	1170
	1171
	1172
	1173
	1174
	1175	#if (!defined(WINDLL) && !defined(MACOS))
	1176
	1177	/***************************/
	1178	/* Function UzpMorePause() */
	1179	/***************************/
	1180
	1181	void UZ_EXP UzpMorePause(pG, prompt, flag)
	1182	zvoid pG; / globals struct: always passed */
	1183	ZCONST char prompt; / "--More--" prompt */
	1184	int flag; /* 0 = any char OK; 1 = accept only '\n', ' ', q */
	1185	{
	1186	#if 0
	1187	uch c;
	1188
	1189	/*---------------------------------------------------------------------------
	1190	Print a prompt and wait for the user to press a key, then erase prompt
	1191	if possible.
	1192	---------------------------------------------------------------------------*/
	1193
	1194	if (!((Uz_Globs *)pG)->sol)
	1195	fprintf(stderr, "\n");
	1196	/* numlines may or may not be used: */
	1197	fprintf(stderr, prompt, ((Uz_Globs *)pG)->numlines);
	1198	fflush(stderr);
	1199	if (flag & 1) {
	1200	do {
	1201	c = (uch)FGETCH(0);
	1202	} while (c != '\r' && c != '\n' && c != ' ' && c != 'q' && c != 'Q');
	1203	} else
	1204	c = (uch)FGETCH(0);
	1205
	1206	/* newline was not echoed, so cover up prompt line */
	1207	fprintf(stderr, LoadFarString(HidePrompt));
	1208	fflush(stderr);
	1209
	1210	if (ToLower(c) == 'q') {
	1211	DESTROYGLOBALS()
	1212	EXIT(PK_COOL);
	1213	}
	1214
	1215	((Uz_Globs *)pG)->sol = TRUE;
	1216
	1217	#endif
	1218	} /* end function UzpMorePause() */
	1219
	1220	#endif /* !WINDLL && !MACOS */
	1221
	1222
	1223
	1224
	1225	#ifndef WINDLL
	1226
	1227	/**************************/
	1228	/* Function UzpPassword() */
	1229	/**************************/
	1230
	1231	int UZ_EXP UzpPassword (pG, rcnt, pwbuf, size, zfn, efn)
	1232	zvoid pG; / pointer to UnZip's internal global vars */
	1233	int rcnt; / retry counter */
	1234	char pwbuf; / buffer for password */
	1235	int size; /* size of password buffer */
	1236	ZCONST char zfn; / name of zip archive */
	1237	ZCONST char efn; / name of archive entry being processed */
	1238	{
	1239	#if CRYPT
	1240	int r = IZ_PW_ENTERED;
	1241	char *m;
	1242	char *prompt;
	1243
	1244	#ifndef REENTRANT
	1245	/* tell picky compilers to shut up about "unused variable" warnings */
	1246	pG = pG;
	1247	#endif
	1248
	1249	if (rcnt == 0) { / First call for current entry */
	1250	*rcnt = 2;
	1251	if ((prompt = (char )malloc(2FILNAMSIZ + 15)) != (char *)NULL) {
	1252	sprintf(prompt, LoadFarString(PasswPrompt),
	1253	FnFilter1(zfn), FnFilter2(efn));
	1254	m = prompt;
	1255	} else
	1256	m = (char *)LoadFarString(PasswPrompt2);
	1257	} else { /* Retry call, previous password was wrong */
	1258	(*rcnt)--;
	1259	prompt = NULL;
	1260	m = (char *)LoadFarString(PasswRetry);
	1261	}
	1262
	1263	m = getp(__G__ m, pwbuf, size);
	1264	if (prompt != (char *)NULL) {
	1265	free(prompt);
	1266	}
	1267	if (m == (char *)NULL) {
	1268	r = IZ_PW_ERROR;
	1269	}
	1270	else if (*pwbuf == '\0') {
	1271	r = IZ_PW_CANCELALL;
	1272	}
	1273	return r;
	1274
	1275	#else /* !CRYPT */
	1276	/* tell picky compilers to shut up about "unused variable" warnings */
	1277	pG = pG; rcnt = rcnt; pwbuf = pwbuf; size = size; zfn = zfn; efn = efn;
	1278
	1279	return IZ_PW_ERROR; /* internal error; function should never get called */
	1280	#endif /* ?CRYPT */
	1281
	1282	} /* end function UzpPassword() */
	1283
	1284
	1285
	1286
	1287
	1288	/**********************/
	1289	/* Function handler() */
	1290	/**********************/
	1291
	1292	void handler(signal) /* upon interrupt, turn on echo and exit cleanly */
	1293	int signal;
	1294	{
	1295	GETGLOBALS();
	1296
	1297	#if !(defined(SIGBUS) \|\| defined(SIGSEGV)) /* add a newline if not at */
	1298	(G.message)((zvoid )&G, slide, 0L, 0x41); /* start of line (to stderr; */
	1299	#endif /* slide[] should be safe) */
	1300
	1301	echon();
	1302
	1303	#ifdef SIGBUS
	1304	if (signal == SIGBUS) {
	1305	Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
	1306	"bus error"));
	1307	DESTROYGLOBALS()
	1308	EXIT(PK_BADERR);
	1309	}
	1310	#endif /* SIGBUS */
	1311
	1312	#ifdef SIGSEGV
	1313	if (signal == SIGSEGV) {
	1314	Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
	1315	"segmentation violation"));
	1316	DESTROYGLOBALS()
	1317	EXIT(PK_BADERR);
	1318	}
	1319	#endif /* SIGSEGV */
	1320
	1321	/* probably ctrl-C */
	1322	DESTROYGLOBALS()
	1323	#if defined(AMIGA) && defined(__SASC)
	1324	_abort();
	1325	#endif
	1326	EXIT(IZ_CTRLC); /* was EXIT(0), then EXIT(PK_ERR) */
	1327	}
	1328
	1329	#endif /* !WINDLL */
	1330
	1331
	1332
	1333
	1334	#if (!defined(VMS) && !defined(CMS_MVS))
	1335	#if (!defined(OS2) \|\| defined(TIMESTAMP))
	1336
	1337	#if (!defined(HAVE_MKTIME) \|\| defined(AMIGA) \|\| defined(WIN32))
	1338	/* also used in amiga/filedate.c and win32/win32.c */
	1339	ZCONST ush ydays[] =
	1340	{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
	1341	#endif
	1342
	1343	/*******************************/
	1344	/* Function dos_to_unix_time() / / used for freshening/updating/timestamps */
	1345	/*******************************/
	1346
	1347	time_t dos_to_unix_time(dosdatetime)
	1348	ulg dosdatetime;
	1349	{
	1350	time_t m_time;
	1351
	1352	#ifdef HAVE_MKTIME
	1353
	1354	ZCONST time_t now = time(NULL);
	1355	struct tm *tm;
	1356	# define YRBASE 1900
	1357
	1358	tm = localtime(&now);
	1359	tm->tm_isdst = -1; /* let mktime determine if DST is in effect */
	1360
	1361	/* dissect date */
	1362	tm->tm_year = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
	1363	tm->tm_mon = ((int)(dosdatetime >> 21) & 0x0f) - 1;
	1364	tm->tm_mday = ((int)(dosdatetime >> 16) & 0x1f);
	1365
	1366	/* dissect time */
	1367	tm->tm_hour = (int)((unsigned)dosdatetime >> 11) & 0x1f;
	1368	tm->tm_min = (int)((unsigned)dosdatetime >> 5) & 0x3f;
	1369	tm->tm_sec = (int)((unsigned)dosdatetime << 1) & 0x3e;
	1370
	1371	m_time = mktime(tm);
	1372	NATIVE_TO_TIMET(m_time) /* NOP unless MSC 7.0 or Macintosh */
	1373	TTrace((stderr, " final m_time = %lu\n", (ulg)m_time));
	1374
	1375	#else /* !HAVE_MKTIME */
	1376
	1377	int yr, mo, dy, hh, mm, ss;
	1378	#ifdef TOPS20
	1379	# define YRBASE 1900
	1380	struct tmx *tmx;
	1381	char temp[20];
	1382	#else /* !TOPS20 */
	1383	# define YRBASE 1970
	1384	int leap;
	1385	unsigned days;
	1386	struct tm *tm;
	1387	#if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
	1388	#ifdef WIN32
	1389	TIME_ZONE_INFORMATION tzinfo;
	1390	DWORD res;
	1391	#else /* ! WIN32 */
	1392	#ifndef BSD4_4 /* GRR: change to !defined(MODERN) ? */
	1393	#if (defined(BSD) \|\| defined(MTS) \|\| defined(__GO32__))
	1394	struct timeb tbp;
	1395	#else /* !(BSD \|\| MTS \|\| __GO32__) */
	1396	#ifdef DECLARE_TIMEZONE
	1397	extern time_t timezone;
	1398	#endif
	1399	#endif /* ?(BSD \|\| MTS \|\| __GO32__) */
	1400	#endif /* !BSD4_4 */
	1401	#endif /* ?WIN32 */
	1402	#endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
	1403	#endif /* ?TOPS20 */
	1404
	1405
	1406	/* dissect date */
	1407	yr = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
	1408	mo = ((int)(dosdatetime >> 21) & 0x0f) - 1;
	1409	dy = ((int)(dosdatetime >> 16) & 0x1f) - 1;
	1410
	1411	/* dissect time */
	1412	hh = (int)((unsigned)dosdatetime >> 11) & 0x1f;
	1413	mm = (int)((unsigned)dosdatetime >> 5) & 0x3f;
	1414	ss = (int)((unsigned)dosdatetime & 0x1f) * 2;
	1415
	1416	#ifdef TOPS20
	1417	tmx = (struct tmx *)malloc(sizeof(struct tmx));
	1418	sprintf (temp, "%02d/%02d/%02d %02d:%02d:%02d", mo+1, dy+1, yr, hh, mm, ss);
	1419	time_parse(temp, tmx, (char *)0);
	1420	m_time = time_make(tmx);
	1421	free(tmx);
	1422
	1423	#else /* !TOPS20 */
	1424
	1425	/*---------------------------------------------------------------------------
	1426	Calculate the number of seconds since the epoch, usually 1 January 1970.
	1427	---------------------------------------------------------------------------*/
	1428
	1429	/* leap = # of leap yrs from YRBASE up to but not including current year */
	1430	leap = ((yr + YRBASE - 1) / 4); /* leap year base factor */
	1431
	1432	/* calculate days from BASE to this year and add expired days this year */
	1433	days = (yr * 365) + (leap - 492) + ydays[mo];
	1434
	1435	/* if year is a leap year and month is after February, add another day */
	1436	if ((mo > 1) && ((yr+YRBASE)%4 == 0) && ((yr+YRBASE) != 2100))
	1437	++days; /* OK through 2199 */
	1438
	1439	/* convert date & time to seconds relative to 00:00:00, 01/01/YRBASE */
	1440	m_time = (time_t)((unsigned long)(days + dy) * 86400L +
	1441	(unsigned long)hh * 3600L +
	1442	(unsigned long)(mm * 60 + ss));
	1443	/* - 1; MS-DOS times always rounded up to nearest even second */
	1444	TTrace((stderr, "dos_to_unix_time:\n"));
	1445	TTrace((stderr, " m_time before timezone = %lu\n", (ulg)m_time));
	1446
	1447	/*---------------------------------------------------------------------------
	1448	Adjust for local standard timezone offset.
	1449	---------------------------------------------------------------------------*/
	1450
	1451	#if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
	1452	#ifdef WIN32
	1453	/* account for timezone differences */
	1454	res = GetTimeZoneInformation(&tzinfo);
	1455	if (res != TIME_ZONE_ID_UNKNOWN)
	1456	{
	1457	m_time += 60*(tzinfo.Bias);
	1458	#else /* !WIN32 */
	1459	#if (defined(BSD) \|\| defined(MTS) \|\| defined(__GO32__))
	1460	#ifdef BSD4_4
	1461	if ( (dosdatetime >= DOSTIME_2038_01_18) &&
	1462	(m_time < (time_t)0x70000000L) )
	1463	m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
	1464	if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
	1465	m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
	1466	if ((tm = localtime(&m_time)) != (struct tm *)NULL)
	1467	m_time -= tm->tm_gmtoff; /* sec. EAST of GMT: subtr. */
	1468	#else /* !(BSD4_4 */
	1469	ftime(&tbp); /* get `timezone' */
	1470	m_time += tbp.timezone * 60L; /* seconds WEST of GMT: add */
	1471	#endif /* ?(BSD4_4 \|\| __EMX__) */
	1472	#else /* !(BSD \|\| MTS \|\| __GO32__) */
	1473	/* tzset was already called at start of process_zipfiles() */
	1474	/* tzset(); / / set `timezone' variable */
	1475	#ifndef __BEOS__ /* BeOS DR8 has no timezones... */
	1476	m_time += timezone; /* seconds WEST of GMT: add */
	1477	#endif
	1478	#endif /* ?(BSD \|\| MTS \|\| __GO32__) */
	1479	#endif /* ?WIN32 */
	1480	TTrace((stderr, " m_time after timezone = %lu\n", (ulg)m_time));
	1481
	1482	/*---------------------------------------------------------------------------
	1483	Adjust for local daylight savings (summer) time.
	1484	---------------------------------------------------------------------------*/
	1485
	1486	#ifndef BSD4_4 /* (DST already added to tm_gmtoff, so skip tm_isdst) */
	1487	if ( (dosdatetime >= DOSTIME_2038_01_18) &&
	1488	(m_time < (time_t)0x70000000L) )
	1489	m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
	1490	if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
	1491	m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
	1492	TIMET_TO_NATIVE(m_time) /* NOP unless MSC 7.0 or Macintosh */
	1493	if (((tm = localtime((time_t *)&m_time)) != NULL) && tm->tm_isdst)
	1494	#ifdef WIN32
	1495	m_time += 60L * tzinfo.DaylightBias; /* adjust with DST bias */
	1496	else
	1497	m_time += 60L * tzinfo.StandardBias; /* add StdBias (normally 0) */
	1498	#else
	1499	m_time -= 60L * 60L; /* adjust for daylight savings time */
	1500	#endif
	1501	NATIVE_TO_TIMET(m_time) /* NOP unless MSC 7.0 or Macintosh */
	1502	TTrace((stderr, " m_time after DST = %lu\n", (ulg)m_time));
	1503	#endif /* !BSD4_4 */
	1504	#ifdef WIN32
	1505	}
	1506	#endif
	1507	#endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
	1508	#endif /* ?TOPS20 */
	1509
	1510	#endif /* ?HAVE_MKTIME */
	1511
	1512	if ( (dosdatetime >= DOSTIME_2038_01_18) &&
	1513	(m_time < (time_t)0x70000000L) )
	1514	m_time = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
	1515	if (m_time < (time_t)0L) /* a converted DOS time cannot be negative */
	1516	m_time = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
	1517
	1518	return m_time;
	1519
	1520	} /* end function dos_to_unix_time() */
	1521
	1522	#endif /* !OS2 \|\| TIMESTAMP */
	1523	#endif /* !VMS && !CMS_MVS */
	1524
	1525
	1526
	1527	#if (!defined(VMS) && !defined(OS2) && !defined(CMS_MVS))
	1528
	1529	/******************************/
	1530	/* Function check_for_newer() / / used for overwriting/freshening/updating */
	1531	/******************************/
	1532
	1533	int check_for_newer(__G__ filename) /* return 1 if existing file is newer */
	1534	__GDEF /* or equal; 0 if older; -1 if doesn't */
	1535	char filename; / exist yet */
	1536	{
	1537	time_t existing, archive;
	1538	#ifdef USE_EF_UT_TIME
	1539	iztimes z_utime;
	1540	#endif
	1541	#ifdef AOS_VS
	1542	long dyy, dmm, ddd, dhh, dmin, dss;
	1543
	1544
	1545	dyy = (lrec.last_mod_dos_datetime >> 25) + 1980;
	1546	dmm = (lrec.last_mod_dos_datetime >> 21) & 0x0f;
	1547	ddd = (lrec.last_mod_dos_datetime >> 16) & 0x1f;
	1548	dhh = (lrec.last_mod_dos_datetime >> 11) & 0x1f;
	1549	dmin = (lrec.last_mod_dos_datetime >> 5) & 0x3f;
	1550	dss = (lrec.last_mod_dos_datetime & 0x1f) * 2;
	1551
	1552	/* under AOS/VS, file times can only be set at creation time,
	1553	* with the info in a special DG format. Make sure we can create
	1554	* it here - we delete it later & re-create it, whether or not
	1555	* it exists now.
	1556	*/
	1557	if (!zvs_create(filename, (((ulg)dgdate(dmm, ddd, dyy)) << 16) \|
	1558	(dhh1800L + dmin30L + dss/2L), -1L, -1L, (char *) -1, -1, -1, -1))
	1559	return DOES_NOT_EXIST;
	1560	#endif /* AOS_VS */
	1561
	1562	Trace((stderr, "check_for_newer: doing stat(%s)\n", FnFilter1(filename)));
	1563	if (SSTAT(filename, &G.statbuf)) {
	1564	Trace((stderr,
	1565	"check_for_newer: stat(%s) returns %d: file does not exist\n",
	1566	FnFilter1(filename), SSTAT(filename, &G.statbuf)));
	1567	#ifdef SYMLINKS
	1568	Trace((stderr, "check_for_newer: doing lstat(%s)\n",
	1569	FnFilter1(filename)));
	1570	/* GRR OPTION: could instead do this test ONLY if G.symlnk is true */
	1571	if (lstat(filename, &G.statbuf) == 0) {
	1572	Trace((stderr,
	1573	"check_for_newer: lstat(%s) returns 0: symlink does exist\n",
	1574	FnFilter1(filename)));
	1575	if (QCOND2 && !uO.overwrite_all)
	1576	Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
	1577	FnFilter1(filename), " with no real file"));
	1578	return EXISTS_AND_OLDER; /* symlink dates are meaningless */
	1579	}
	1580	#endif /* SYMLINKS */
	1581	return DOES_NOT_EXIST;
	1582	}
	1583	Trace((stderr, "check_for_newer: stat(%s) returns 0: file exists\n",
	1584	FnFilter1(filename)));
	1585
	1586	#ifdef SYMLINKS
	1587	/* GRR OPTION: could instead do this test ONLY if G.symlnk is true */
	1588	if (lstat(filename, &G.statbuf) == 0 && S_ISLNK(G.statbuf.st_mode)) {
	1589	Trace((stderr, "check_for_newer: %s is a symbolic link\n",
	1590	FnFilter1(filename)));
	1591	if (QCOND2 && !uO.overwrite_all)
	1592	Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
	1593	FnFilter1(filename), ""));
	1594	return EXISTS_AND_OLDER; /* symlink dates are meaningless */
	1595	}
	1596	#endif /* SYMLINKS */
	1597
	1598	NATIVE_TO_TIMET(G.statbuf.st_mtime) /* NOP unless MSC 7.0 or Macintosh */
	1599
	1600	#ifdef USE_EF_UT_TIME
	1601	/* The `Unix extra field mtime' should be used for comparison with the
	1602	* time stamp of the existing file >>>ONLY<<< when the EF info is also
	1603	* used to set the modification time of the extracted file.
	1604	*/
	1605	if (G.extra_field &&
	1606	#ifdef IZ_CHECK_TZ
	1607	G.tz_is_valid &&
	1608	#endif
	1609	(ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
	1610	G.lrec.last_mod_dos_datetime, &z_utime, NULL)
	1611	& EB_UT_FL_MTIME))
	1612	{
	1613	TTrace((stderr, "check_for_newer: using Unix extra field mtime\n"));
	1614	existing = G.statbuf.st_mtime;
	1615	archive = z_utime.mtime;
	1616	} else {
	1617	/* round up existing filetime to nearest 2 seconds for comparison,
	1618	* but saturate in case of arithmetic overflow
	1619	*/
	1620	existing = ((G.statbuf.st_mtime & 1) &&
	1621	(G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
	1622	G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
	1623	archive = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
	1624	}
	1625	#else /* !USE_EF_UT_TIME */
	1626	/* round up existing filetime to nearest 2 seconds for comparison,
	1627	* but saturate in case of arithmetic overflow
	1628	*/
	1629	existing = ((G.statbuf.st_mtime & 1) &&
	1630	(G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
	1631	G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
	1632	archive = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
	1633	#endif /* ?USE_EF_UT_TIME */
	1634
	1635	TTrace((stderr, "check_for_newer: existing %lu, archive %lu, e-a %ld\n",
	1636	(ulg)existing, (ulg)archive, (long)(existing-archive)));
	1637
	1638	return (existing >= archive);
	1639
	1640	} /* end function check_for_newer() */
	1641
	1642	#endif /* !VMS && !OS2 && !CMS_MVS */
	1643
	1644
	1645
	1646
	1647
	1648	/************************/
	1649	/* Function do_string() */
	1650	/************************/
	1651
	1652	int do_string(__G__ len, option) /* return PK-type error code */
	1653	__GDEF
	1654	unsigned int len; /* without prototype, ush converted to this */
	1655	int option;
	1656	{
	1657	long comment_bytes_left, block_length;
	1658	int error=PK_OK;
	1659	ush extra_len;
	1660	#ifdef AMIGA
	1661	char tmp_fnote[2 * AMIGA_FILENOTELEN]; /* extra room for squozen chars */
	1662	#endif
	1663
	1664
	1665	/*---------------------------------------------------------------------------
	1666	This function processes arbitrary-length (well, usually) strings. Four
	1667	options are allowed: SKIP, wherein the string is skipped (pretty logical,
	1668	eh?); DISPLAY, wherein the string is printed to standard output after un-
	1669	dergoing any necessary or unnecessary character conversions; DS_FN,
	1670	wherein the string is put into the filename[] array after undergoing ap-
	1671	propriate conversions (including case-conversion, if that is indicated:
	1672	see the global variable pInfo->lcflag); and EXTRA_FIELD, wherein the
	1673	`string' is assumed to be an extra field and is copied to the (freshly
	1674	malloced) buffer G.extra_field. The third option should be OK since
	1675	filename is dimensioned at 1025, but we check anyway.
	1676
	1677	The string, by the way, is assumed to start at the current file-pointer
	1678	position; its length is given by len. So start off by checking length
	1679	of string: if zero, we're already done.
	1680	---------------------------------------------------------------------------*/
	1681
	1682	if (!len)
	1683	return PK_COOL;
	1684
	1685	switch (option) {
	1686
	1687	/*
	1688	* First case: print string on standard output. First set loop vari-
	1689	* ables, then loop through the comment in chunks of OUTBUFSIZ bytes,
	1690	* converting formats and printing as we go. The second half of the
	1691	* loop conditional was added because the file might be truncated, in
	1692	* which case comment_bytes_left will remain at some non-zero value for
	1693	* all time. outbuf and slide are used as scratch buffers because they
	1694	* are available (we should be either before or in between any file pro-
	1695	* cessing).
	1696	*/
	1697
	1698	case DISPLAY:
	1699	case DISPL_8:
	1700	comment_bytes_left = len;
	1701	block_length = OUTBUFSIZ; /* for the while statement, first time */
	1702	while (comment_bytes_left > 0 && block_length > 0) {
	1703	register uch *p = G.outbuf;
	1704	register uch *q = G.outbuf;
	1705
	1706	if ((block_length = readbuf(__G__ (char *)G.outbuf,
	1707	(unsigned) MIN((long)OUTBUFSIZ, comment_bytes_left))) == 0)
	1708	return PK_EOF;
	1709	comment_bytes_left -= block_length;
	1710
	1711	/* this is why we allocated an extra byte for outbuf: terminate
	1712	* with zero (ASCIIZ) */
	1713	G.outbuf[(unsigned)block_length] = '\0';
	1714
	1715	/* remove all ASCII carriage returns from comment before printing
	1716	* (since used before A_TO_N(), check for CR instead of '\r')
	1717	*/
	1718	while (*p) {
	1719	while (*p == CR)
	1720	++p;
	1721	q++ = p++;
	1722	}
	1723	/* could check whether (p - outbuf) == block_length here */
	1724	*q = '\0';
	1725
	1726	if (option == DISPL_8) {
	1727	/* translate the text coded in the entry's host-dependent
	1728	"extended ASCII" charset into the compiler's (system's)
	1729	internal text code page */
	1730	Ext_ASCII_TO_Native((char *)G.outbuf, G.pInfo->hostnum,
	1731	G.crec.version_made_by[0]);
	1732	#ifdef WINDLL
	1733	/* translate to ANSI (RTL internal codepage may be OEM) */
	1734	INTERN_TO_ISO((char )G.outbuf, (char )G.outbuf);
	1735	#else /* !WINDLL */
	1736	#ifdef WIN32
	1737	/* Win9x console always uses OEM character coding, and
	1738	WinNT console is set to OEM charset by default, too */
	1739	INTERN_TO_OEM((char )G.outbuf, (char )G.outbuf);
	1740	#endif /* WIN32 */
	1741	#endif /* ?WINDLL */
	1742	} else {
	1743	A_TO_N(G.outbuf); /* translate string to native */
	1744	}
	1745
	1746	#ifdef WINDLL
	1747	/* ran out of local mem -- had to cheat */
	1748	win_fprintf((zvoid )&G, stdout, len, (char )G.outbuf);
	1749	win_fprintf((zvoid )&G, stdout, 2, (char )"\n\n");
	1750	#else /* !WINDLL */
	1751	#ifdef NOANSIFILT /* GRR: can ANSI be used with EBCDIC? */
	1752	(G.message)((zvoid )&G, G.outbuf, (ulg)(q-G.outbuf), 0);
	1753	#else /* ASCII, filter out ANSI escape sequences and handle ^S (pause) */
	1754	p = G.outbuf - 1;
	1755	q = slide;
	1756	while (*++p) {
	1757	int pause = FALSE;
	1758
	1759	if (p == 0x1B) { / ASCII escape char */
	1760	*q++ = '^';
	1761	*q++ = '[';
	1762	} else if (p == 0x13) { / ASCII ^S (pause) */
	1763	pause = TRUE;
	1764	if (p[1] == LF) /* ASCII LF */
	1765	q++ = ++p;
	1766	else if (p[1] == CR && p[2] == LF) { /* ASCII CR LF */
	1767	q++ = ++p;
	1768	q++ = ++p;
	1769	}
	1770	} else
	1771	q++ = p;
	1772	if ((unsigned)(q-slide) > WSIZE-3 \|\| pause) { /* flush */
	1773	(G.message)((zvoid )&G, slide, (ulg)(q-slide), 0);
	1774	q = slide;
	1775	if (pause && G.extract_flag) /* don't pause for list/test */
	1776	(G.mpause)((zvoid )&G, LoadFarString(QuitPrompt), 0);
	1777	}
	1778	}
	1779	(G.message)((zvoid )&G, slide, (ulg)(q-slide), 0);
	1780	#endif /* ?NOANSIFILT */
	1781	#endif /* ?WINDLL */
	1782	}
	1783	/* add '\n' if not at start of line */
	1784	(G.message)((zvoid )&G, slide, 0L, 0x40);
	1785	break;
	1786
	1787	/*
	1788	* Second case: read string into filename[] array. The filename should
	1789	* never ever be longer than FILNAMSIZ-1 (1024), but for now we'll check,
	1790	* just to be sure.
	1791	*/
	1792
	1793	case DS_FN:
	1794	extra_len = 0;
	1795	if (len >= FILNAMSIZ) {
	1796	Info(slide, 0x401, ((char *)slide,
	1797	LoadFarString(FilenameTooLongTrunc)));
	1798	error = PK_WARN;
	1799	extra_len = (ush)(len - FILNAMSIZ + 1);
	1800	len = FILNAMSIZ - 1;
	1801	}
	1802	if (readbuf(__G__ G.filename, len) == 0)
	1803	return PK_EOF;
	1804	G.filename[len] = '\0'; /* terminate w/zero: ASCIIZ */
	1805
	1806	/* translate the Zip entry filename coded in host-dependent "extended
	1807	ASCII" into the compiler's (system's) internal text code page */
	1808	Ext_ASCII_TO_Native(G.filename, G.pInfo->hostnum,
	1809	G.crec.version_made_by[0]);
	1810
	1811	if (G.pInfo->lcflag) /* replace with lowercase filename */
	1812	TOLOWER(G.filename, G.filename);
	1813
	1814	if (G.pInfo->vollabel && len > 8 && G.filename[8] == '.') {
	1815	char *p = G.filename+8;
	1816	while (*p++)
	1817	p[-1] = p; / disk label, and 8th char is dot: remove dot */
	1818	}
	1819
	1820	if (!extra_len) /* we're done here */
	1821	break;
	1822
	1823	/*
	1824	* We truncated the filename, so print what's left and then fall
	1825	* through to the SKIP routine.
	1826	*/
	1827	Info(slide, 0x401, ((char *)slide, "[ %s ]\n", FnFilter1(G.filename)));
	1828	len = extra_len;
	1829	/* FALL THROUGH... */
	1830
	1831	/*
	1832	* Third case: skip string, adjusting readbuf's internal variables
	1833	* as necessary (and possibly skipping to and reading a new block of
	1834	* data).
	1835	*/
	1836
	1837	case SKIP:
	1838	/* cur_zipfile_bufstart already takes account of extra_bytes, so don't
	1839	* correct for it twice: */
	1840	ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes +
	1841	(G.inptr-G.inbuf) + len)
	1842	break;
	1843
	1844	/*
	1845	* Fourth case: assume we're at the start of an "extra field"; malloc
	1846	* storage for it and read data into the allocated space.
	1847	*/
	1848
	1849	case EXTRA_FIELD:
	1850	if (G.extra_field != (uch *)NULL)
	1851	free(G.extra_field);
	1852	if ((G.extra_field = (uch )malloc(len)) == (uch )NULL) {
	1853	Info(slide, 0x401, ((char *)slide, LoadFarString(ExtraFieldTooLong),
	1854	len));
	1855	/* cur_zipfile_bufstart already takes account of extra_bytes,
	1856	* so don't correct for it twice: */
	1857	ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes +
	1858	(G.inptr-G.inbuf) + len)
	1859	} else
	1860	if (readbuf(__G__ (char *)G.extra_field, len) == 0)
	1861	return PK_EOF;
	1862	break;
	1863
	1864	#ifdef AMIGA
	1865	/*
	1866	* Fifth case, for the Amiga only: take the comment that would ordinarily
	1867	* be skipped over, and turn it into a 79 character string that will be
	1868	* attached to the file as a "filenote" after it is extracted.
	1869	*/
	1870
	1871	case FILENOTE:
	1872	if ((extra_len = readbuf(__G__ tmp_fnote, (unsigned)
	1873	MIN(len, 2 * AMIGA_FILENOTELEN - 1))) == 0)
	1874	return PK_EOF;
	1875	if ((len -= extra_len) > 0) /* treat remainder as in case SKIP: */
	1876	ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes
	1877	+ (G.inptr - G.inbuf) + len)
	1878	/* convert multi-line text into single line with no ctl-chars: */
	1879	tmp_fnote[extra_len] = '\0';
	1880	while ((short int) --extra_len >= 0)
	1881	if ((unsigned) tmp_fnote[extra_len] < ' ')
	1882	if (tmp_fnote[extra_len+1] == ' ') /* no excess */
	1883	strcpy(tmp_fnote+extra_len, tmp_fnote+extra_len+1);
	1884	else
	1885	tmp_fnote[extra_len] = ' ';
	1886	tmp_fnote[AMIGA_FILENOTELEN - 1] = '\0';
	1887	if (G.filenotes[G.filenote_slot])
	1888	free(G.filenotes[G.filenote_slot]); /* should not happen */
	1889	G.filenotes[G.filenote_slot] = NULL;
	1890	if (tmp_fnote[0]) {
	1891	if (!(G.filenotes[G.filenote_slot] = malloc(strlen(tmp_fnote)+1)))
	1892	return PK_MEM;
	1893	strcpy(G.filenotes[G.filenote_slot], tmp_fnote);
	1894	}
	1895	break;
	1896	#endif /* AMIGA */
	1897
	1898	} /* end switch (option) */
	1899
	1900	return error;
	1901
	1902	} /* end function do_string() */
	1903
	1904
	1905
	1906
	1907
	1908	/***********************/
	1909	/* Function makeword() */
	1910	/***********************/
	1911
	1912	ush makeword(b)
	1913	ZCONST uch *b;
	1914	{
	1915	/*
	1916	* Convert Intel style 'short' integer to non-Intel non-16-bit
	1917	* host format. This routine also takes care of byte-ordering.
	1918	*/
	1919	return (ush)((b[1] << 8) \| b[0]);
	1920	}
	1921
	1922
	1923
	1924
	1925
	1926	/***********************/
	1927	/* Function makelong() */
	1928	/***********************/
	1929
	1930	ulg makelong(sig)
	1931	ZCONST uch *sig;
	1932	{
	1933	/*
	1934	* Convert intel style 'long' variable to non-Intel non-16-bit
	1935	* host format. This routine also takes care of byte-ordering.
	1936	*/
	1937	return (((ulg)sig[3]) << 24)
	1938	+ (((ulg)sig[2]) << 16)
	1939	+ (((ulg)sig[1]) << 8)
	1940	+ ((ulg)sig[0]);
	1941	}
	1942
	1943
	1944
	1945	#if CRYPT
	1946
	1947	#ifdef NEED_STR2ISO
	1948	/**********************/
	1949	/* Function str2iso() */
	1950	/**********************/
	1951
	1952	char *str2iso(dst, src)
	1953	char dst; / destination buffer */
	1954	register ZCONST char src; / source string */
	1955	{
	1956	#ifdef INTERN_TO_ISO
	1957	INTERN_TO_ISO(src, dst);
	1958	#else
	1959	register uch c;
	1960	register char *dstp = dst;
	1961
	1962	do {
	1963	c = (uch)foreign(*src++);
	1964	*dstp++ = (char)ASCII2ISO(c);
	1965	} while (c != '\0');
	1966	#endif
	1967
	1968	return dst;
	1969	}
	1970	#endif /* NEED_STR2ISO */
	1971
	1972
	1973	#ifdef NEED_STR2OEM
	1974	/**********************/
	1975	/* Function str2oem() */
	1976	/**********************/
	1977
	1978	char *str2oem(dst, src)
	1979	char dst; / destination buffer */
	1980	register ZCONST char src; / source string */
	1981	{
	1982	#ifdef INTERN_TO_OEM
	1983	INTERN_TO_OEM(src, dst);
	1984	#else
	1985	register uch c;
	1986	register char *dstp = dst;
	1987
	1988	do {
	1989	c = (uch)foreign(*src++);
	1990	*dstp++ = (char)ASCII2OEM(c);
	1991	} while (c != '\0');
	1992	#endif
	1993
	1994	return dst;
	1995	}
	1996	#endif /* NEED_STR2OEM */
	1997
	1998	#endif /* CRYPT */
	1999
	2000
	2001	#ifdef ZMEM /* memset/memcmp/memcpy for systems without either them or */
	2002	/* bzero/bcmp/bcopy */
	2003	/* (no known systems as of 960211) */
	2004
	2005	/*********************/
	2006	/* Function memset() */
	2007	/*********************/
	2008
	2009	zvoid *memset(buf, init, len)
	2010	register zvoid buf; / buffer location */
	2011	register int init; /* initializer character */
	2012	register unsigned int len; /* length of the buffer */
	2013	{
	2014	zvoid *start;
	2015
	2016	start = buf;
	2017	while (len--)
	2018	((char )buf++) = (char)init;
	2019	return start;
	2020	}
	2021
	2022
	2023
	2024	/*********************/
	2025	/* Function memcmp() */
	2026	/*********************/
	2027
	2028	int memcmp(b1, b2, len)
	2029	register ZCONST zvoid *b1;
	2030	register ZCONST zvoid *b2;
	2031	register unsigned int len;
	2032	{
	2033	register int c;
	2034
	2035	if (len > 0) do {
	2036	if ((c = (int)(((ZCONST unsigned char )b1)++) -
	2037	(int)(((ZCONST unsigned char )b2)++)) != 0)
	2038	return c;
	2039	} while (--len > 0)
	2040	return 0;
	2041	}
	2042
	2043
	2044
	2045	/*********************/
	2046	/* Function memcpy() */
	2047	/*********************/
	2048
	2049	zvoid *memcpy(dst, src, len)
	2050	register zvoid *dst;
	2051	register ZCONST zvoid *src;
	2052	register unsigned int len;
	2053	{
	2054	zvoid *start;
	2055
	2056	start = dst;
	2057	while (len-- > 0)
	2058	((char )dst)++ = ((ZCONST char )src)++;
	2059	return start;
	2060	}
	2061
	2062	#endif /* ZMEM */
	2063
	2064
	2065
	2066
	2067
	2068	/************************/
	2069	/* Function zstrnicmp() */
	2070	/************************/
	2071
	2072	int zstrnicmp(s1, s2, n)
	2073	register ZCONST char s1, s2;
	2074	register unsigned n;
	2075	{
	2076	for (; n > 0; --n, ++s1, ++s2) {
	2077
	2078	if (ToLower(s1) != ToLower(s2))
	2079	/* test includes early termination of one string */
	2080	return (ToLower(s1) < ToLower(s2))? -1 : 1;
	2081
	2082	if (s1 == '\0') / both strings terminate early */
	2083	return 0;
	2084	}
	2085	return 0;
	2086	}
	2087
	2088
	2089
	2090
	2091
	2092	#ifdef REGULUS /* returns the inode number on success(!)...argh argh argh */
	2093	# undef stat
	2094
	2095	/********************/
	2096	/* Function zstat() */
	2097	/********************/
	2098
	2099	int zstat(p, s)
	2100	char *p;
	2101	struct stat *s;
	2102	{
	2103	return (stat(p,s) >= 0? 0 : (-1));
	2104	}
	2105
	2106	#endif /* REGULUS */
	2107
	2108
	2109
	2110
	2111
	2112	#ifdef SMALL_MEM
	2113
	2114	/*******************************/
	2115	/* Function fLoadFarString() / / (and friends...) */
	2116	/*******************************/
	2117
	2118	char fLoadFarString(__GPRO__ const char Far sz)
	2119	{
	2120	(void)zfstrcpy(G.rgchBigBuffer, sz);
	2121	return G.rgchBigBuffer;
	2122	}
	2123
	2124	char fLoadFarStringSmall(__GPRO__ const char Far sz)
	2125	{
	2126	(void)zfstrcpy(G.rgchSmallBuffer, sz);
	2127	return G.rgchSmallBuffer;
	2128	}
	2129
	2130	char fLoadFarStringSmall2(__GPRO__ const char Far sz)
	2131	{
	2132	(void)zfstrcpy(G.rgchSmallBuffer2, sz);
	2133	return G.rgchSmallBuffer2;
	2134	}
	2135
	2136
	2137
	2138
	2139	#if (!defined(_MSC_VER) \|\| (_MSC_VER < 600))
	2140	/*************************/
	2141	/* Function zfstrcpy() / / portable clone of _fstrcpy() */
	2142	/*************************/
	2143
	2144	char Far * Far zfstrcpy(char Far s1, const char Far s2)
	2145	{
	2146	char Far *p = s1;
	2147
	2148	while ((s1++ = s2++) != '\0');
	2149	return p;
	2150	}
	2151	#endif /* !_MSC_VER \|\| (_MSC_VER < 600) */
	2152
	2153	#endif /* SMALL_MEM */