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

... / ...

Commit	Line	Data
	1	/*---------------------------------------------------------------------------
	2
	3	os2.c
	4
	5	OS/2-specific routines for use with Info-ZIP's UnZip 5.1 and later.
	6
	7	This file contains the OS/2 versions of the file name/attribute/time/etc
	8	code. Most or all of the routines which make direct use of OS/2 system
	9	calls (i.e., the non-lowercase routines) are Kai Uwe Rommel's. The read-
	10	dir() suite was written by Michael Rendell and ported to OS/2 by Kai Uwe;
	11	it is in the public domain.
	12
	13	Contains: GetCountryInfo()
	14	GetFileTime()
	15	SetFileTime() (TIMESTAMP only)
	16	stamp_file() (TIMESTAMP only)
	17	Utime2DosDateTime()
	18	SetPathAttrTimes()
	19	SetEAs()
	20	GetLoadPath()
	21	opendir()
	22	closedir()
	23	readdir()
	24	[ seekdir() ] not used
	25	[ telldir() ] not used
	26	free_dircontents()
	27	getdirent()
	28	IsFileSystemFAT()
	29	do_wild()
	30	mapattr()
	31	mapname()
	32	checkdir()
	33	isfloppy()
	34	IsFileNameValid()
	35	map2fat()
	36	SetLongNameEA()
	37	close_outfile()
	38	check_for_newer()
	39	dateformat()
	40	version()
	41	InitNLS()
	42	IsUpperNLS()
	43	ToLowerNLS()
	44	StringLower()
	45	DebugMalloc()
	46
	47	---------------------------------------------------------------------------*/
	48
	49
	50	#define UNZIP_INTERNAL
	51	#include "unzip.h"
	52	#include "os2acl.h"
	53
	54	extern ZCONST char Far TruncEAs[];
	55
	56	/* local prototypes */
	57
	58	#ifdef TIMESTAMP
	59	static int SetFileTime(ZCONST char *name, ulg stamp);
	60	#endif
	61	#if defined(USE_EF_UT_TIME) \|\| defined(TIMESTAMP)
	62	static ulg Utime2DosDateTime OF((time_t uxtime));
	63	#endif
	64	static int getOS2filetimes OF((__GPRO__
	65	ulg pM_dt, ulg pA_dt, ulg *pC_dt));
	66	static void SetPathAttrTimes OF((__GPRO__ int flags, int dir));
	67	static int SetEAs OF((__GPRO__ const char *path,
	68	void *ef_block));
	69	static int SetACL OF((__GPRO__ const char *path,
	70	void *ef_block));
	71	static int EvalExtraFields OF((__GPRO__ const char *path,
	72	void *extra_field, unsigned ef_len));
	73	static int isfloppy OF((int nDrive));
	74	static int IsFileNameValid OF((const char *name));
	75	static void map2fat OF((char pathcomp, char *pEndFAT));
	76	static int SetLongNameEA OF((char name, char longname));
	77	static void InitNLS OF((void));
	78
	79
	80	/*****************************/
	81	/* Strings used in os2.c */
	82	/*****************************/
	83
	84	#ifndef SFX
	85	static char Far CantAllocateWildcard[] =
	86	"warning: cannot allocate wildcard buffers\n";
	87	#endif
	88	static char Far Creating[] = " creating: %-22s ";
	89	static char Far ConversionFailed[] = "mapname: conversion of %s failed\n";
	90	static char Far Labelling[] = "labelling %c: %-22s\n";
	91	static char Far ErrSetVolLabel[] = "mapname: error setting volume label\n";
	92	static char Far PathTooLong[] = "checkdir error: path too long: %s\n";
	93	static char Far CantCreateDir[] = "checkdir error: cannot create %s\n\
	94	unable to process %s.\n";
	95	static char Far DirIsntDirectory[] =
	96	"checkdir error: %s exists but is not directory\n\
	97	unable to process %s.\n";
	98	static char Far PathTooLongTrunc[] =
	99	"checkdir warning: path too long; truncating\n %s\n\
	100	-> %s\n";
	101	#if (!defined(SFX) \|\| defined(SFX_EXDIR))
	102	static char Far CantCreateExtractDir[] =
	103	"checkdir: cannot create extraction directory: %s\n";
	104	#endif
	105
	106	#ifndef __EMX__
	107	# if (_MSC_VER >= 600) \|\| defined(__IBMC__)
	108	# include <direct.h> /* have special MSC/IBM C mkdir prototype */
	109	# else /* own prototype because dir.h conflicts? */
	110	int mkdir(const char *path);
	111	# endif
	112	# define MKDIR(path,mode) mkdir(path)
	113	#else
	114	# define MKDIR(path,mode) mkdir(path,mode)
	115	#endif
	116
	117
	118	#ifdef __32BIT__
	119
	120	USHORT DosDevIOCtl32(PVOID pData, USHORT cbData, PVOID pParms, USHORT cbParms,
	121	USHORT usFunction, USHORT usCategory, HFILE hDevice)
	122	{
	123	ULONG ulParmLengthInOut = cbParms, ulDataLengthInOut = cbData;
	124	return (USHORT) DosDevIOCtl(hDevice, usCategory, usFunction,
	125	pParms, cbParms, &ulParmLengthInOut,
	126	pData, cbData, &ulDataLengthInOut);
	127	}
	128
	129	# define DosDevIOCtl DosDevIOCtl32
	130	#else
	131	# define DosDevIOCtl DosDevIOCtl2
	132	#endif
	133
	134
	135	typedef struct
	136	{
	137	ush nID;
	138	ush nSize;
	139	ulg lSize;
	140	}
	141	EFHEADER, *PEFHEADER;
	142
	143
	144	#ifdef __32BIT__
	145
	146	#define DosFindFirst(p1, p2, p3, p4, p5, p6) \
	147	DosFindFirst(p1, p2, p3, p4, p5, p6, 1)
	148
	149	#else
	150
	151	typedef struct
	152	{
	153	ULONG oNextEntryOffset;
	154	BYTE fEA;
	155	BYTE cbName;
	156	USHORT cbValue;
	157	CHAR szName[1];
	158	}
	159	FEA2, *PFEA2;
	160
	161	typedef struct
	162	{
	163	ULONG cbList;
	164	FEA2 list[1];
	165	}
	166	FEA2LIST, *PFEA2LIST;
	167
	168	#define DosQueryCurrentDisk DosQCurDisk
	169	#define DosQueryFSAttach(p1, p2, p3, p4, p5) \
	170	DosQFSAttach(p1, p2, p3, p4, p5, 0)
	171	#define DosEnumAttribute(p1, p2, p3, p4, p5, p6, p7) \
	172	DosEnumAttribute(p1, p2, p3, p4, p5, p6, p7, 0)
	173	#define DosFindFirst(p1, p2, p3, p4, p5, p6) \
	174	DosFindFirst(p1, p2, p3, p4, p5, p6, 0)
	175	#define DosMapCase DosCaseMap
	176	#define DosSetPathInfo(p1, p2, p3, p4, p5) \
	177	DosSetPathInfo(p1, p2, p3, p4, p5, 0)
	178	#define DosQueryPathInfo(p1, p2, p3, p4) \
	179	DosQPathInfo(p1, p2, p3, p4, 0)
	180	#define DosQueryFileInfo DosQFileInfo
	181	#define DosMapCase DosCaseMap
	182	#define DosQueryCtryInfo DosGetCtryInfo
	183
	184	#endif /* !__32BIT__ */
	185
	186
	187
	188
	189
	190	/*
	191	* @(#) dir.h 1.4 87/11/06 Public Domain.
	192	*/
	193
	194	#define A_RONLY 0x01
	195	#define A_HIDDEN 0x02
	196	#define A_SYSTEM 0x04
	197	#define A_LABEL 0x08
	198	#define A_DIR 0x10
	199	#define A_ARCHIVE 0x20
	200
	201
	202	const int attributes = A_DIR \| A_HIDDEN \| A_SYSTEM;
	203
	204
	205	extern DIR opendir(__GPRO__ ZCONST char );
	206	extern struct direct readdir(__GPRO__ DIR );
	207	extern void seekdir(DIR *, long);
	208	extern long telldir(DIR *);
	209	extern void closedir(DIR *);
	210	#define rewinddir(dirp) seekdir(dirp, 0L)
	211
	212	int IsFileSystemFAT(__GPRO__ ZCONST char *dir);
	213	char StringLower(char szArg);
	214
	215
	216
	217
	218	/*
	219	* @(#)dir.c 1.4 87/11/06 Public Domain.
	220	*/
	221
	222
	223	#ifndef S_IFMT
	224	# define S_IFMT 0xF000
	225	#endif
	226
	227
	228	#ifndef SFX
	229	static char getdirent(__GPRO__ ZCONST char );
	230	static void free_dircontents(struct _dircontents *);
	231	#endif /* !SFX */
	232
	233
	234
	235
	236	int GetCountryInfo(void)
	237	{
	238	COUNTRYINFO ctryi;
	239	COUNTRYCODE ctryc;
	240	#ifdef __32BIT__
	241	ULONG cbInfo;
	242	#else
	243	USHORT cbInfo;
	244	#endif
	245
	246	ctryc.country = ctryc.codepage = 0;
	247
	248	if ( DosQueryCtryInfo(sizeof(ctryi), &ctryc, &ctryi, &cbInfo) != NO_ERROR )
	249	return 0;
	250
	251	return ctryi.fsDateFmt;
	252	}
	253
	254
	255	long GetFileTime(ZCONST char *name)
	256	{
	257	#ifdef __32BIT__
	258	FILESTATUS3 fs;
	259	#else
	260	FILESTATUS fs;
	261	#endif
	262	USHORT nDate, nTime;
	263
	264	if ( DosQueryPathInfo((PSZ) name, 1, (PBYTE) &fs, sizeof(fs)) )
	265	return -1;
	266
	267	nDate = * (USHORT *) &fs.fdateLastWrite;
	268	nTime = * (USHORT *) &fs.ftimeLastWrite;
	269
	270	return ((ULONG) nDate) << 16 \| nTime;
	271	}
	272
	273
	274	#ifdef TIMESTAMP
	275
	276	static int SetFileTime(ZCONST char name, ulg stamp) / swiped from Zip */
	277	{
	278	FILESTATUS fs;
	279	USHORT fd, ft;
	280
	281	if (DosQueryPathInfo((PSZ) name, FIL_STANDARD, (PBYTE) &fs, sizeof(fs)))
	282	return -1;
	283
	284	fd = (USHORT) (stamp >> 16);
	285	ft = (USHORT) stamp;
	286	fs.fdateLastWrite = fs.fdateCreation = * (FDATE *) &fd;
	287	fs.ftimeLastWrite = fs.ftimeCreation = * (FTIME *) &ft;
	288
	289	if (DosSetPathInfo((PSZ) name, FIL_STANDARD, (PBYTE) &fs, sizeof(fs), 0))
	290	return -1;
	291
	292	return 0;
	293	}
	294
	295
	296	int stamp_file(ZCONST char *fname, time_t modtime)
	297	{
	298	return SetFileTime(fname, Utime2DosDateTime(modtime));
	299	}
	300
	301	#endif /* TIMESTAMP */
	302
	303
	304	/* The following DOS date/time structures are machine-dependent as they
	305	* assume "little-endian" byte order. For OS/2-specific code, which
	306	* is run on x86 CPUs (or emulators?), this assumption is valid; but
	307	* care should be taken when using this code as template for other ports.
	308	*/
	309	typedef union {
	310	ULONG timevalue; /* combined value, useful for comparisons */
	311	struct {
	312	FTIME ft; /* system file time record:
	313	* USHORT twosecs : 5
	314	* USHORT minutes : 6;
	315	* USHORT hours : 5; */
	316	FDATE fd; /* system file date record:
	317	* USHORT day : 5
	318	* USHORT month : 4;
	319	* USHORT year : 7; */
	320	} _fdt;
	321	} F_DATE_TIME, *PF_DATE_TIME;
	322
	323
	324	#if defined(USE_EF_UT_TIME) \|\| defined(TIMESTAMP)
	325
	326	static ulg Utime2DosDateTime(uxtime)
	327	time_t uxtime;
	328	{
	329	F_DATE_TIME dosfiletime;
	330	struct tm *t;
	331
	332	/* round up to even seconds */
	333	/* round up (down if "up" overflows) to even seconds */
	334	if (((ulg)uxtime) & 1)
	335	uxtime = (uxtime + 1 > uxtime) ? uxtime + 1 : uxtime - 1;
	336
	337	t = localtime(&(uxtime));
	338	if (t == (struct tm *)NULL) {
	339	/* time conversion error; use current time instead, hoping
	340	that localtime() does not reject it as well! */
	341	time_t now = time(NULL);
	342	t = localtime(&now);
	343	}
	344	if (t->tm_year < 80) {
	345	dosfiletime._fdt.ft.twosecs = 0;
	346	dosfiletime._fdt.ft.minutes = 0;
	347	dosfiletime._fdt.ft.hours = 0;
	348	dosfiletime._fdt.fd.day = 1;
	349	dosfiletime._fdt.fd.month = 1;
	350	dosfiletime._fdt.fd.year = 0;
	351	} else {
	352	dosfiletime._fdt.ft.twosecs = t->tm_sec >> 1;
	353	dosfiletime._fdt.ft.minutes = t->tm_min;
	354	dosfiletime._fdt.ft.hours = t->tm_hour;
	355	dosfiletime._fdt.fd.day = t->tm_mday;
	356	dosfiletime._fdt.fd.month = t->tm_mon + 1;
	357	dosfiletime._fdt.fd.year = t->tm_year - 80;
	358	}
	359	return dosfiletime.timevalue;
	360
	361	} /* end function Utime2DosDateTime() */
	362
	363	#endif /* USE_EF_UT_TIME \|\| TIMESTAMP */
	364
	365
	366	static int getOS2filetimes(__GPRO__ ulg pM_dt, ulg pA_dt, ulg *pC_dt)
	367	{
	368	#ifdef USE_EF_UT_TIME
	369	unsigned eb_izux_flg;
	370	iztimes z_utime;
	371	#endif
	372
	373	/* Copy and/or convert time and date variables, if necessary; */
	374	/* return a flag indicating which time stamps are available. */
	375	#ifdef USE_EF_UT_TIME
	376	if (G.extra_field &&
	377	#ifdef IZ_CHECK_TZ
	378	G.tz_is_valid &&
	379	#endif
	380	((eb_izux_flg = ef_scan_for_izux(G.extra_field,
	381	G.lrec.extra_field_length, 0, G.lrec.last_mod_dos_datetime,
	382	&z_utime, NULL)) & EB_UT_FL_MTIME))
	383	{
	384	TTrace((stderr, "getOS2filetimes: UT e.f. modif. time = %lu\n",
	385	z_utime.mtime));
	386	*pM_dt = Utime2DosDateTime(z_utime.mtime);
	387	if (eb_izux_flg & EB_UT_FL_ATIME) {
	388	TTrace((stderr, "getOS2filetimes: UT e.f. access time = %lu\n",
	389	z_utime.atime));
	390	*pA_dt = Utime2DosDateTime(z_utime.atime);
	391	}
	392	if (eb_izux_flg & EB_UT_FL_CTIME) {
	393	TTrace((stderr, "getOS2filetimes: UT e.f. creation time = %lu\n",
	394	z_utime.ctime));
	395	*pC_dt = Utime2DosDateTime(z_utime.ctime);
	396	} else {
	397	/* no creation time value supplied, set it to modification time */
	398	pC_dt = pM_dt;
	399	eb_izux_flg \|= EB_UT_FL_CTIME;
	400	}
	401	return (int)eb_izux_flg;
	402	}
	403	#endif /* USE_EF_UT_TIME */
	404	pC_dt = pM_dt = G.lrec.last_mod_dos_datetime;
	405	TTrace((stderr, "\ngetOS2filetimes: DOS dir modific./creation time = %lu\n",
	406	*pM_dt));
	407	return (EB_UT_FL_MTIME \| EB_UT_FL_CTIME);
	408	}
	409
	410
	411	static void SetPathAttrTimes(__GPRO__ int flags, int dir)
	412	{
	413	HFILE hFile;
	414	#ifdef __32BIT__
	415	ULONG nAction;
	416	#else
	417	USHORT nAction;
	418	#endif
	419	FILESTATUS fs;
	420	USHORT nLength;
	421	char szName[CCHMAXPATH];
	422	ulg Mod_dt, Acc_dt, Cre_dt;
	423	int gotTimes;
	424
	425	strcpy(szName, G.filename);
	426	nLength = strlen(szName);
	427	if (szName[nLength - 1] == '/')
	428	szName[nLength - 1] = 0;
	429
	430	if (dir)
	431	{
	432	if ( DosQueryPathInfo(szName, FIL_STANDARD, (PBYTE) &fs, sizeof(fs)) )
	433	return;
	434	}
	435	else
	436	{
	437	/* for regular files, open them and operate on the file handle, to
	438	work around certain network operating system bugs ... */
	439
	440	if ( DosOpen(szName, &hFile, &nAction, 0, 0,
	441	OPEN_ACTION_OPEN_IF_EXISTS \| OPEN_ACTION_CREATE_IF_NEW,
	442	OPEN_SHARE_DENYREADWRITE \| OPEN_ACCESS_READWRITE, 0) )
	443	return;
	444
	445	if ( DosQueryFileInfo(hFile, FIL_STANDARD, (PBYTE) &fs, sizeof(fs)) )
	446	return;
	447	}
	448
	449	/* set date/time stamps */
	450	gotTimes = getOS2filetimes(__G__ &Mod_dt, &Acc_dt, &Cre_dt);
	451	if (gotTimes & EB_UT_FL_MTIME) {
	452	fs.fdateLastWrite = ((F_DATE_TIME *)&Mod_dt)->_fdt.fd;
	453	fs.ftimeLastWrite = ((F_DATE_TIME *)&Mod_dt)->_fdt.ft;
	454	}
	455	if (gotTimes & EB_UT_FL_ATIME) {
	456	fs.fdateLastAccess = ((F_DATE_TIME *)&Acc_dt)->_fdt.fd;
	457	fs.ftimeLastAccess = ((F_DATE_TIME *)&Acc_dt)->_fdt.ft;
	458	}
	459	if (gotTimes & EB_UT_FL_CTIME) {
	460	fs.fdateCreation = ((F_DATE_TIME *)&Cre_dt)->_fdt.fd;
	461	fs.ftimeCreation = ((F_DATE_TIME *)&Cre_dt)->_fdt.ft;
	462	}
	463
	464	if ( flags != -1 )
	465	fs.attrFile = flags; /* hidden, system, archive, read-only */
	466
	467	if (dir)
	468	{
	469	DosSetPathInfo(szName, FIL_STANDARD, (PBYTE) &fs, sizeof(fs), 0);
	470	}
	471	else
	472	{
	473	DosSetFileInfo(hFile, FIL_STANDARD, (PBYTE) &fs, sizeof(fs));
	474	DosClose(hFile);
	475	}
	476	}
	477
	478
	479	typedef struct
	480	{
	481	ULONG cbList; /* length of value + 22 */
	482	#ifdef __32BIT__
	483	ULONG oNext;
	484	#endif
	485	BYTE fEA; /* 0 */
	486	BYTE cbName; /* length of ".LONGNAME" = 9 */
	487	USHORT cbValue; /* length of value + 4 */
	488	BYTE szName[10]; /* ".LONGNAME" */
	489	USHORT eaType; /* 0xFFFD for length-preceded ASCII */
	490	USHORT eaSize; /* length of value */
	491	BYTE szValue[CCHMAXPATH];
	492	}
	493	FEALST;
	494
	495
	496	static int SetEAs(__GPRO__ const char path, void ef_block)
	497	{ /* returns almost-PK errors */
	498	EFHEADER *pEAblock = (PEFHEADER) ef_block;
	499	#ifdef __32BIT__
	500	EAOP2 eaop;
	501	PFEA2LIST pFEA2list;
	502	#else
	503	EAOP eaop;
	504	PFEALIST pFEAlist;
	505	PFEA pFEA;
	506	PFEA2LIST pFEA2list;
	507	PFEA2 pFEA2;
	508	ULONG nLength2;
	509	#endif
	510	USHORT nLength;
	511	char szName[CCHMAXPATH];
	512	int error;
	513
	514	if ( ef_block == NULL \|\| pEAblock -> nID != EF_OS2 )
	515	return PK_OK; /* not an OS/2 extra field: assume OK */
	516
	517	if ( pEAblock->nSize < 4 \|\| (pEAblock->lSize > 0L && pEAblock->nSize <= 10) )
	518	return IZ_EF_TRUNC; /* no compressed data! */
	519
	520	strcpy(szName, path);
	521	nLength = strlen(szName);
	522	if (szName[nLength - 1] == '/')
	523	szName[nLength - 1] = 0;
	524
	525	if ( (pFEA2list = (PFEA2LIST) malloc((size_t) pEAblock -> lSize)) == NULL )
	526	return PK_MEM4;
	527
	528	if ( (error = memextract(__G__ (uch *)pFEA2list, pEAblock->lSize,
	529	(uch *)(pEAblock+1), (ulg)(pEAblock->nSize - 4))) != PK_OK )
	530	{
	531	free(pFEA2list);
	532	return error;
	533	}
	534
	535	#ifdef __32BIT__
	536	eaop.fpGEA2List = NULL;
	537	eaop.fpFEA2List = pFEA2list;
	538	#else
	539	pFEAlist = (PVOID) pFEA2list;
	540	pFEA2 = pFEA2list -> list;
	541	pFEA = pFEAlist -> list;
	542
	543	do
	544	{
	545	nLength2 = pFEA2 -> oNextEntryOffset;
	546	nLength = sizeof(FEA) + pFEA2 -> cbName + 1 + pFEA2 -> cbValue;
	547
	548	memcpy(pFEA, (PCH) pFEA2 + sizeof(pFEA2 -> oNextEntryOffset), nLength);
	549
	550	pFEA2 = (PFEA2) ((PCH) pFEA2 + nLength2);
	551	pFEA = (PFEA) ((PCH) pFEA + nLength);
	552	}
	553	while ( nLength2 != 0 );
	554
	555	pFEAlist -> cbList = (PCH) pFEA - (PCH) pFEAlist;
	556
	557	eaop.fpGEAList = NULL;
	558	eaop.fpFEAList = pFEAlist;
	559	#endif
	560
	561	eaop.oError = 0;
	562	DosSetPathInfo(szName, FIL_QUERYEASIZE, (PBYTE) &eaop, sizeof(eaop), 0);
	563
	564	if (!uO.tflag && QCOND2)
	565	Info(slide, 0, ((char *)slide, " (%ld bytes EAs)", pFEA2list -> cbList));
	566
	567	free(pFEA2list);
	568	return PK_COOL;
	569	}
	570
	571
	572	static int SetACL(__GPRO__ const char path, void ef_block)
	573	{ /* returns almost-PK errors */
	574	EFHEADER *pACLblock = (PEFHEADER) ef_block;
	575	char *szACL;
	576	int error;
	577
	578	if ( ef_block == NULL \|\| pACLblock -> nID != EF_ACL )
	579	return PK_OK; /* not an OS/2 extra field: assume OK */
	580
	581	if (pACLblock->nSize < 4 \|\| (pACLblock->lSize > 0L && pACLblock->nSize <= 10))
	582	return IZ_EF_TRUNC; /* no compressed data! */
	583
	584	if ( (szACL = malloc((size_t) pACLblock -> lSize)) == NULL )
	585	return PK_MEM4;
	586
	587	if ( (error = memextract(__G__ (uch *)szACL, pACLblock->lSize,
	588	(uch *)(pACLblock+1), (ulg)(pACLblock->nSize - 4))) != PK_OK )
	589	{
	590	free(szACL);
	591	return error;
	592	}
	593
	594	if (acl_set(NULL, path, szACL) == 0)
	595	if (!uO.tflag && QCOND2)
	596	Info(slide, 0, ((char *)slide, " (%ld bytes ACL)", strlen(szACL)));
	597
	598	free(szACL);
	599	return PK_COOL;
	600	}
	601
	602
	603	#ifdef SFX
	604
	605	char *GetLoadPath(__GPRO)
	606	{
	607	#ifdef __32BIT__ /* generic for 32-bit API */
	608	PTIB pptib;
	609	PPIB pppib;
	610	char *szPath;
	611
	612	DosGetInfoBlocks(&pptib, &pppib);
	613	szPath = pppib -> pib_pchenv;
	614	#else /* 16-bit, note: requires large data model */
	615	SEL selEnv;
	616	USHORT offCmd;
	617	char *szPath;
	618
	619	DosGetEnv(&selEnv, &offCmd);
	620	szPath = MAKEP(selEnv, 0);
	621	#endif
	622
	623	while (szPath) / find end of process environment */
	624	szPath = strchr(szPath, 0) + 1;
	625
	626	return szPath + 1; /* .exe file name follows environment */
	627
	628	} /* end function GetLoadPath() */
	629
	630
	631
	632
	633
	634	#else /* !SFX */
	635
	636	DIR opendir(__GPRO__ const char name)
	637	{
	638	struct stat statb;
	639	DIR *dirp;
	640	char c;
	641	char *s;
	642	struct _dircontents *dp;
	643	char nbuf[MAXPATHLEN + 1];
	644	int len;
	645
	646	strcpy(nbuf, name);
	647	if ((len = strlen(nbuf)) == 0)
	648	return NULL;
	649
	650	if ( ((c = nbuf[len - 1]) == '\\' \|\| c == '/') && (len > 1) )
	651	{
	652	nbuf[len - 1] = 0;
	653	--len;
	654
	655	if ( nbuf[len - 1] == ':' )
	656	{
	657	strcpy(nbuf+len, "\\.");
	658	len += 2;
	659	}
	660	}
	661	else
	662	if ( nbuf[len - 1] == ':' )
	663	{
	664	strcpy(nbuf+len, ".");
	665	++len;
	666	}
	667
	668	/* GRR: Borland and Watcom C return non-zero on wildcards... < 0 ? */
	669	if (stat(nbuf, &statb) < 0 \|\| (statb.st_mode & S_IFMT) != S_IFDIR)
	670	{
	671	Trace((stderr, "opendir: stat(%s) returns negative or not directory\n",
	672	nbuf));
	673	return NULL;
	674	}
	675
	676	if ( (dirp = malloc(sizeof(DIR))) == NULL )
	677	return NULL;
	678
	679	if ( nbuf[len - 1] == '.' && (len == 1 \|\| nbuf[len - 2] != '.') )
	680	strcpy(nbuf+len-1, "*");
	681	else
	682	if ( ((c = nbuf[len - 1]) == '\\' \|\| c == '/') && (len == 1) )
	683	strcpy(nbuf+len, "*");
	684	else
	685	strcpy(nbuf+len, "\\*");
	686
	687	/* len is no longer correct (but no longer needed) */
	688	Trace((stderr, "opendir: nbuf = [%s]\n", nbuf));
	689
	690	dirp -> dd_loc = 0;
	691	dirp -> dd_contents = dirp -> dd_cp = NULL;
	692
	693	if ((s = getdirent(__G__ nbuf)) == NULL)
	694	return dirp;
	695
	696	do
	697	{
	698	if (((dp = malloc(sizeof(struct _dircontents))) == NULL) \|\|
	699	((dp -> _d_entry = malloc(strlen(s) + 1)) == NULL) )
	700	{
	701	if (dp)
	702	free(dp);
	703	free_dircontents(dirp -> dd_contents);
	704
	705	return NULL;
	706	}
	707
	708	if (dirp -> dd_contents)
	709	{
	710	dirp -> dd_cp -> _d_next = dp;
	711	dirp -> dd_cp = dirp -> dd_cp -> _d_next;
	712	}
	713	else
	714	dirp -> dd_contents = dirp -> dd_cp = dp;
	715
	716	strcpy(dp -> _d_entry, s);
	717	dp -> _d_next = NULL;
	718
	719	dp -> _d_size = G.os2.find.cbFile;
	720	dp -> _d_mode = G.os2.find.attrFile;
	721	dp -> _d_time = (unsigned ) &(G.os2.find.ftimeLastWrite);
	722	dp -> _d_date = (unsigned ) &(G.os2.find.fdateLastWrite);
	723	}
	724	while ((s = getdirent(__G__ NULL)) != NULL);
	725
	726	dirp -> dd_cp = dirp -> dd_contents;
	727
	728	return dirp;
	729	}
	730
	731
	732	void closedir(DIR * dirp)
	733	{
	734	free_dircontents(dirp -> dd_contents);
	735	free(dirp);
	736	}
	737
	738
	739	struct direct readdir(__GPRO__ DIR dirp)
	740	{
	741	/* moved to os2data.h so it can be global */
	742	/* static struct direct dp; */
	743
	744	if (dirp -> dd_cp == NULL)
	745	return NULL;
	746
	747	G.os2.dp.d_namlen = G.os2.dp.d_reclen =
	748	strlen(strcpy(G.os2.dp.d_name, dirp -> dd_cp -> _d_entry));
	749
	750	G.os2.dp.d_ino = 0;
	751
	752	G.os2.dp.d_size = dirp -> dd_cp -> _d_size;
	753	G.os2.dp.d_mode = dirp -> dd_cp -> _d_mode;
	754	G.os2.dp.d_time = dirp -> dd_cp -> _d_time;
	755	G.os2.dp.d_date = dirp -> dd_cp -> _d_date;
	756
	757	dirp -> dd_cp = dirp -> dd_cp -> _d_next;
	758	dirp -> dd_loc++;
	759
	760	return &G.os2.dp;
	761	}
	762
	763
	764
	765	#if 0 /* not used in unzip; retained for possibly future use */
	766
	767	void seekdir(DIR * dirp, long off)
	768	{
	769	long i = off;
	770	struct _dircontents *dp;
	771
	772	if (off >= 0)
	773	{
	774	for (dp = dirp -> dd_contents; --i >= 0 && dp; dp = dp -> _d_next);
	775
	776	dirp -> dd_loc = off - (i + 1);
	777	dirp -> dd_cp = dp;
	778	}
	779	}
	780
	781
	782	long telldir(DIR * dirp)
	783	{
	784	return dirp -> dd_loc;
	785	}
	786
	787	#endif /* 0 */
	788
	789
	790
	791	static void free_dircontents(struct _dircontents * dp)
	792	{
	793	struct _dircontents *odp;
	794
	795	while (dp)
	796	{
	797	if (dp -> _d_entry)
	798	free(dp -> _d_entry);
	799
	800	dp = (odp = dp) -> _d_next;
	801	free(odp);
	802	}
	803	}
	804
	805
	806	static char getdirent(__GPRO__ ZCONST char dir)
	807	{
	808	int done;
	809	/* moved to os2data.h so it can be global */
	810	/* static int lower; */
	811
	812	if (dir != NULL)
	813	{ /* get first entry */
	814	G.os2.hdir = HDIR_SYSTEM;
	815	G.os2.count = 1;
	816	done = DosFindFirst((PSZ) dir, &G.os2.hdir, attributes,
	817	&G.os2.find, sizeof(G.os2.find), &G.os2.count);
	818	G.os2.lower = IsFileSystemFAT(__G__ dir);
	819	}
	820	else /* get next entry */
	821	done = DosFindNext(G.os2.hdir,
	822	&G.os2.find, sizeof(G.os2.find), &G.os2.count);
	823
	824	if (done == 0)
	825	{
	826	if ( G.os2.lower )
	827	StringLower(G.os2.find.achName);
	828	return G.os2.find.achName;
	829	}
	830	else
	831	{
	832	DosFindClose(G.os2.hdir);
	833	return NULL;
	834	}
	835	}
	836
	837
	838
	839	int IsFileSystemFAT(__GPRO__ ZCONST char dir) / FAT / HPFS detection */
	840	{
	841	/* moved to os2data.h so they can be global */
	842	/* static USHORT nLastDrive=(USHORT)(-1), nResult; */
	843	ULONG lMap;
	844	BYTE bData[64];
	845	char bName[3];
	846	#ifdef __32BIT__
	847	ULONG nDrive, cbData;
	848	PFSQBUFFER2 pData = (PFSQBUFFER2) bData;
	849	#else
	850	USHORT nDrive, cbData;
	851	PFSQBUFFER pData = (PFSQBUFFER) bData;
	852	#endif
	853
	854	/* We separate FAT and HPFS+other file systems here.
	855	at the moment I consider other systems to be similar to HPFS,
	856	i.e. support long file names and case sensitive */
	857
	858	if ( isalpha(dir[0]) && (dir[1] == ':') )
	859	nDrive = toupper(dir[0]) - '@';
	860	else
	861	DosQueryCurrentDisk(&nDrive, &lMap);
	862
	863	if ( nDrive == G.os2.nLastDrive )
	864	return G.os2.nResult;
	865
	866	bName[0] = (char) (nDrive + '@');
	867	bName[1] = ':';
	868	bName[2] = 0;
	869
	870	G.os2.nLastDrive = nDrive;
	871	cbData = sizeof(bData);
	872
	873	if ( !DosQueryFSAttach(bName, 0, FSAIL_QUERYNAME, (PVOID) pData, &cbData) )
	874	G.os2.nResult = !strcmp((char *) (pData -> szFSDName) + pData -> cbName,
	875	"FAT");
	876	else
	877	G.os2.nResult = FALSE;
	878
	879	/* End of this ugly code */
	880	return G.os2.nResult;
	881	} /* end function IsFileSystemFAT() */
	882
	883
	884
	885
	886
	887	/************************/
	888	/* Function do_wild() */
	889	/************************/
	890
	891	char *do_wild(__G__ wildspec)
	892	__GDEF
	893	char wildspec; / only used first time on a given dir */
	894	{
	895	/* moved to os2data.h so they can be global */
	896	#if 0
	897	static DIR *dir = NULL;
	898	static char dirname, wildname, matchname[FILNAMSIZ];
	899	static int firstcall=TRUE, have_dirname, dirnamelen;
	900	#endif
	901	char *fnamestart;
	902	struct direct *file;
	903
	904
	905	/* Even when we're just returning wildspec, we always do so in
	906	* matchname[]--calling routine is allowed to append four characters
	907	* to the returned string, and wildspec may be a pointer to argv[].
	908	*/
	909	if (G.os2.firstcall) { /* first call: must initialize everything */
	910	G.os2.firstcall = FALSE;
	911
	912	if (!iswild(wildspec)) {
	913	strcpy(G.os2.matchname, wildspec);
	914	G.os2.have_dirname = FALSE;
	915	G.os2.dir = NULL;
	916	return G.os2.matchname;
	917	}
	918
	919	/* break the wildspec into a directory part and a wildcard filename */
	920	if ((G.os2.wildname = strrchr(wildspec, '/')) == NULL &&
	921	(G.os2.wildname = strrchr(wildspec, ':')) == NULL) {
	922	G.os2.dirname = ".";
	923	G.os2.dirnamelen = 1;
	924	G.os2.have_dirname = FALSE;
	925	G.os2.wildname = wildspec;
	926	} else {
	927	++G.os2.wildname; /* point at character after '/' or ':' */
	928	G.os2.dirnamelen = G.os2.wildname - wildspec;
	929	if ((G.os2.dirname = (char *)malloc(G.os2.dirnamelen+1)) == NULL) {
	930	Info(slide, 1, ((char *)slide,
	931	LoadFarString(CantAllocateWildcard)));
	932	strcpy(G.os2.matchname, wildspec);
	933	return G.os2.matchname; /* but maybe filespec was not a wildcard */
	934	}
	935	strncpy(G.os2.dirname, wildspec, G.os2.dirnamelen);
	936	G.os2.dirname[G.os2.dirnamelen] = '\0'; /* terminate for strcpy below */
	937	G.os2.have_dirname = TRUE;
	938	}
	939	Trace((stderr, "do_wild: dirname = [%s]\n", G.os2.dirname));
	940
	941	if ((G.os2.dir = opendir(__G__ G.os2.dirname)) != NULL) {
	942	if (G.os2.have_dirname) {
	943	strcpy(G.os2.matchname, G.os2.dirname);
	944	fnamestart = G.os2.matchname + G.os2.dirnamelen;
	945	} else
	946	fnamestart = G.os2.matchname;
	947	while ((file = readdir(__G__ G.os2.dir)) != NULL) {
	948	Trace((stderr, "do_wild: readdir returns %s\n", file->d_name));
	949	strcpy(fnamestart, file->d_name);
	950	if (strrchr(fnamestart, '.') == (char *)NULL)
	951	strcat(fnamestart, ".");
	952	if (match(fnamestart, G.os2.wildname, 1) && /* 1 == ignore case */
	953	/* skip "." and ".." directory entries */
	954	strcmp(fnamestart, ".") && strcmp(fnamestart, "..")) {
	955	Trace((stderr, "do_wild: match() succeeds\n"));
	956	/* remove trailing dot */
	957	fnamestart += strlen(fnamestart) - 1;
	958	if (*fnamestart == '.')
	959	*fnamestart = '\0';
	960	return G.os2.matchname;
	961	}
	962	}
	963	/* if we get to here directory is exhausted, so close it */
	964	closedir(G.os2.dir);
	965	G.os2.dir = NULL;
	966	}
	967	#ifdef DEBUG
	968	else {
	969	Trace((stderr, "do_wild: opendir(%s) returns NULL\n", G.os2.dirname));
	970	}
	971	#endif /* DEBUG */
	972
	973	/* return the raw wildspec in case that works (e.g., directory not
	974	* searchable, but filespec was not wild and file is readable) */
	975	strcpy(G.os2.matchname, wildspec);
	976	return G.os2.matchname;
	977	}
	978
	979	/* last time through, might have failed opendir but returned raw wildspec */
	980	if (G.os2.dir == NULL) {
	981	G.os2.firstcall = TRUE; /* nothing left to try--reset for new wildspec */
	982	if (G.os2.have_dirname)
	983	free(G.os2.dirname);
	984	return (char *)NULL;
	985	}
	986
	987	/* If we've gotten this far, we've read and matched at least one entry
	988	* successfully (in a previous call), so dirname has been copied into
	989	* matchname already.
	990	*/
	991	if (G.os2.have_dirname) {
	992	/* strcpy(G.os2.matchname, G.os2.dirname); */
	993	fnamestart = G.os2.matchname + G.os2.dirnamelen;
	994	} else
	995	fnamestart = G.os2.matchname;
	996	while ((file = readdir(__G__ G.os2.dir)) != NULL) {
	997	Trace((stderr, "do_wild: readdir returns %s\n", file->d_name));
	998	strcpy(fnamestart, file->d_name);
	999	if (strrchr(fnamestart, '.') == (char *)NULL)
	1000	strcat(fnamestart, ".");
	1001	if (match(fnamestart, G.os2.wildname, 1)) { /* 1 == ignore case */
	1002	Trace((stderr, "do_wild: match() succeeds\n"));
	1003	/* remove trailing dot */
	1004	fnamestart += strlen(fnamestart) - 1;
	1005	if (*fnamestart == '.')
	1006	*fnamestart = '\0';
	1007	return G.os2.matchname;
	1008	}
	1009	}
	1010
	1011	closedir(G.os2.dir); /* have read at least one dir entry; nothing left */
	1012	G.os2.dir = NULL;
	1013	G.os2.firstcall = TRUE; /* reset for new wildspec */
	1014	if (G.os2.have_dirname)
	1015	free(G.os2.dirname);
	1016	return (char *)NULL;
	1017
	1018	} /* end function do_wild() */
	1019
	1020	#endif /* !SFX */
	1021
	1022
	1023	/* scan extra fields for something we happen to know */
	1024
	1025	static int EvalExtraFields(__GPRO__ const char *path,
	1026	void *extra_field, unsigned ef_len)
	1027	{
	1028	char *ef_ptr = extra_field;
	1029	PEFHEADER pEFblock;
	1030	int rc = PK_OK;
	1031
	1032	while (ef_len >= sizeof(EFHEADER))
	1033	{
	1034	pEFblock = (PEFHEADER) ef_ptr;
	1035
	1036	if (pEFblock -> nSize > (ef_len - EB_HEADSIZE))
	1037	return PK_ERR; /* claimed EFblock length exceeds EF size! */
	1038
	1039	switch (pEFblock -> nID)
	1040	{
	1041	case EF_OS2:
	1042	rc = SetEAs(__G__ path, ef_ptr);
	1043	break;
	1044	case EF_ACL:
	1045	rc = (uO.X_flag) ? SetACL(__G__ path, ef_ptr) : PK_OK;
	1046	break;
	1047	#if 0
	1048	case EF_IZUNIX:
	1049	case EF_PKUNIX:
	1050	/* handled elsewhere */
	1051	break;
	1052	#endif
	1053	default:
	1054	TTrace((stderr,"EvalExtraFields: unknown extra field block, ID=%d\n",
	1055	pEFblock -> nID));
	1056	break;
	1057	}
	1058
	1059	ef_ptr += (pEFblock -> nSize + EB_HEADSIZE);
	1060	ef_len -= (pEFblock -> nSize + EB_HEADSIZE);
	1061
	1062	if (rc != PK_OK)
	1063	break;
	1064	}
	1065
	1066	return rc;
	1067	}
	1068
	1069
	1070
	1071	/************************/
	1072	/* Function mapattr() */
	1073	/************************/
	1074
	1075	int mapattr(__G)
	1076	__GDEF
	1077	{
	1078	/* set archive bit (file is not backed up): */
	1079	G.pInfo->file_attr = (unsigned)(G.crec.external_file_attributes \| 32) & 0xff;
	1080	return 0;
	1081	}
	1082
	1083
	1084
	1085
	1086
	1087	/************************/
	1088	/* Function mapname() */
	1089	/************************/
	1090
	1091	/*
	1092	* There are presently two possibilities in OS/2: the output filesystem is
	1093	* FAT, or it is HPFS. If the former, we need to map to FAT, obviously, but
	1094	* we also must map to HPFS and store that version of the name in extended
	1095	* attributes. Either way, we need to map to HPFS, so the main mapname
	1096	* routine does that. In the case that the output file system is FAT, an
	1097	* extra filename-mapping routine is called in checkdir(). While it should
	1098	* be possible to determine the filesystem immediately upon entry to mapname(),
	1099	* it is conceivable that the DOS APPEND utility could be added to OS/2 some-
	1100	* day, allowing a FAT directory to be APPENDed to an HPFS drive/path. There-
	1101	* fore we simply check the filesystem at each path component.
	1102	*
	1103	* Note that when alternative IFSes become available/popular, everything will
	1104	* become immensely more complicated. For example, a Minix filesystem would
	1105	* have limited filename lengths like FAT but no extended attributes in which
	1106	* to store the longer versions of the names. A BSD Unix filesystem would
	1107	* support paths of length 1024 bytes or more, but it is not clear that FAT
	1108	* EAs would allow such long .LONGNAME fields or that OS/2 would properly
	1109	* restore such fields when moving files from FAT to the new filesystem.
	1110	*
	1111	* GRR: some or all of the following chars should be checked in either
	1112	* mapname (HPFS) or map2fat (FAT), depending: ,=^+'"[]<>\|\t&
	1113	*/
	1114	/* return 0 if no error, 1 if caution (filename */
	1115	int mapname(__G__ renamed) /* truncated), 2 if warning (skip file because */
	1116	__GDEF /* dir doesn't exist), 3 if error (skip file), */
	1117	int renamed; /* or 10 if out of memory (skip file) */
	1118	{ /* [also IZ_VOL_LABEL, IZ_CREATED_DIR] */
	1119	char pathcomp[FILNAMSIZ]; /* path-component buffer */
	1120	char pp, cp=(char )NULL; / character pointers */
	1121	char lastsemi=(char )NULL; /* pointer to last semi-colon in pathcomp */
	1122	int quote = FALSE; /* flag: next char is literal */
	1123	int error = 0;
	1124	register unsigned workch; /* hold the character being tested */
	1125
	1126
	1127	/*---------------------------------------------------------------------------
	1128	Initialize various pointers and counters and stuff.
	1129	---------------------------------------------------------------------------*/
	1130
	1131	/* can create path as long as not just freshening, or if user told us */
	1132	G.create_dirs = (!uO.fflag \|\| renamed);
	1133
	1134	G.os2.created_dir = FALSE; /* not yet */
	1135	G.os2.renamed_fullpath = FALSE;
	1136	G.os2.fnlen = strlen(G.filename);
	1137
	1138	/* GRR: for VMS, convert to internal format now or later? or never? */
	1139	if (renamed) {
	1140	cp = G.filename - 1; /* point to beginning of renamed name... */
	1141	while (*++cp)
	1142	if (cp == '\\') / convert backslashes to forward */
	1143	*cp = '/';
	1144	cp = G.filename;
	1145	/* use temporary rootpath if user gave full pathname */
	1146	if (G.filename[0] == '/') {
	1147	G.os2.renamed_fullpath = TRUE;
	1148	pathcomp[0] = '/'; /* copy the '/' and terminate */
	1149	pathcomp[1] = '\0';
	1150	++cp;
	1151	} else if (isalpha(G.filename[0]) && G.filename[1] == ':') {
	1152	G.os2.renamed_fullpath = TRUE;
	1153	pp = pathcomp;
	1154	pp++ = cp++; /* copy the "d:" (+ '/', possibly) */
	1155	pp++ = cp++;
	1156	if (*cp == '/')
	1157	pp++ = cp++; /* otherwise add "./"? */
	1158	*pp = '\0';
	1159	}
	1160	}
	1161
	1162	/* pathcomp is ignored unless renamed_fullpath is TRUE: */
	1163	if ((error = checkdir(__G__ pathcomp, INIT)) != 0) /* init path buffer */
	1164	return error; /* ...unless no mem or vol label on hard disk */
	1165
	1166	pathcomp = '\0'; / initialize translation buffer */
	1167	pp = pathcomp; /* point to translation buffer */
	1168	if (!renamed) { /* cp already set if renamed */
	1169	if (uO.jflag) /* junking directories */
	1170	/* GRR: watch out for VMS version... */
	1171	cp = (char *)strrchr(G.filename, '/');
	1172	if (cp == (char )NULL) / no '/' or not junking dirs */
	1173	cp = G.filename; /* point to internal zipfile-member pathname */
	1174	else
	1175	++cp; /* point to start of last component of path */
	1176	}
	1177
	1178	/*---------------------------------------------------------------------------
	1179	Begin main loop through characters in filename.
	1180	---------------------------------------------------------------------------*/
	1181
	1182	while ((workch = (uch)*cp++) != 0) {
	1183
	1184	if (quote) { /* if character quoted, */
	1185	pp++ = (char)workch; / include it literally */
	1186	quote = FALSE;
	1187	} else
	1188	switch (workch) {
	1189	case '/': /* can assume -j flag not given */
	1190	*pp = '\0';
	1191	if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1)
	1192	return error;
	1193	pp = pathcomp; /* reset conversion buffer for next piece */
	1194	lastsemi = (char )NULL; / leave directory semi-colons alone */
	1195	break;
	1196
	1197	case ':':
	1198	pp++ = '_'; / drive names not stored in zipfile, */
	1199	break; /* so no colons allowed */
	1200
	1201	case ';': /* start of VMS version? */
	1202	lastsemi = pp; /* remove VMS version later... */
	1203	pp++ = ';'; / but keep semicolon for now */
	1204	break;
	1205
	1206	case '\026': /* control-V quote for special chars */
	1207	quote = TRUE; /* set flag for next character */
	1208	break;
	1209
	1210	case ' ': /* keep spaces unless specifically */
	1211	if (uO.sflag) /* requested to change to underscore */
	1212	*pp++ = '_';
	1213	else
	1214	*pp++ = ' ';
	1215	break;
	1216
	1217	default:
	1218	/* allow ASCII 255 and European characters in filenames: */
	1219	if (isprint(workch) \|\| workch >= 127)
	1220	*pp++ = (char)workch;
	1221	} /* end switch */
	1222
	1223	} /* end while loop */
	1224
	1225	pp = '\0'; / done with pathcomp: terminate it */
	1226
	1227	/* if not saving them, remove VMS version numbers (appended "###") */
	1228	if (!uO.V_flag && lastsemi) {
	1229	pp = lastsemi + 1; /* semi-colon was kept: expect #s after */
	1230	while (isdigit((uch)(*pp)))
	1231	++pp;
	1232	if (pp == '\0') / only digits between ';' and end: nuke */
	1233	*lastsemi = '\0';
	1234	}
	1235
	1236	/*---------------------------------------------------------------------------
	1237	Report if directory was created (and no file to create: filename ended
	1238	in '/'), check name to be sure it exists, and combine path and name be-
	1239	fore exiting.
	1240	---------------------------------------------------------------------------*/
	1241
	1242	if (G.filename[G.os2.fnlen-1] == '/') {
	1243	checkdir(__G__ G.filename, GETPATH);
	1244	if (G.os2.created_dir) {
	1245	if (!uO.qflag)
	1246	Info(slide, 0, ((char *)slide, LoadFarString(Creating),
	1247	G.filename));
	1248	if (G.extra_field) { /* zipfile extra field has extended attribs */
	1249	int err = EvalExtraFields(__G__ G.filename, G.extra_field,
	1250	G.lrec.extra_field_length);
	1251
	1252	if (err == IZ_EF_TRUNC) {
	1253	if (uO.qflag)
	1254	Info(slide, 1, ((char *)slide, "%-22s ", G.filename));
	1255	Info(slide, 1, ((char *)slide, LoadFarString(TruncEAs),
	1256	makeword(G.extra_field+2)-10, "\n"));
	1257	} else if (!uO.qflag)
	1258	(G.message)((zvoid )&G, (uch *)"\n", 1L, 0);
	1259	} else if (!uO.qflag)
	1260	(G.message)((zvoid )&G, (uch *)"\n", 1L, 0);
	1261
	1262	/* set date/time stamps */
	1263	SetPathAttrTimes(__G__ G.pInfo->file_attr & ~A_ARCHIVE, 1);
	1264
	1265	return IZ_CREATED_DIR; /* dir time already set */
	1266
	1267	} else if (G.extra_field && uO.overwrite_all) {
	1268	/* overwrite EAs of existing directory since user requested it */
	1269	int err = EvalExtraFields(__G__ G.filename, G.extra_field,
	1270	G.lrec.extra_field_length);
	1271
	1272	if (err == IZ_EF_TRUNC) {
	1273	Info(slide, 0x421, ((char *)slide, "%-22s ", G.filename));
	1274	Info(slide, 0x401, ((char *)slide, LoadFarString(TruncEAs),
	1275	makeword(G.extra_field+2)-10, "\n"));
	1276	}
	1277
	1278	/* set date/time stamps (dirs only have creation times) */
	1279	SetPathAttrTimes(__G__ G.pInfo->file_attr & ~A_ARCHIVE, 1);
	1280	}
	1281	return 2; /* dir existed already; don't look for data to extract */
	1282	}
	1283
	1284	if (*pathcomp == '\0') {
	1285	Info(slide, 1, ((char *)slide, LoadFarString(ConversionFailed),
	1286	G.filename));
	1287	return 3;
	1288	}
	1289
	1290	checkdir(__G__ pathcomp, APPEND_NAME); /* returns 1 if truncated: care? */
	1291	checkdir(__G__ G.filename, GETPATH);
	1292	Trace((stderr, "mapname returns with filename = [%s] (error = %d)\n\n",
	1293	G.filename, error));
	1294
	1295	if (G.pInfo->vollabel) { /* set the volume label now */
	1296	VOLUMELABEL FSInfoBuf;
	1297	/* GRR: "VOLUMELABEL" defined for IBM C and emx, but haven't checked MSC... */
	1298
	1299	strcpy(FSInfoBuf.szVolLabel, G.filename);
	1300	FSInfoBuf.cch = (BYTE)strlen(FSInfoBuf.szVolLabel);
	1301
	1302	if (!uO.qflag)
	1303	Info(slide, 0, ((char *)slide, LoadFarString(Labelling),
	1304	(char)(G.os2.nLabelDrive + 'a' - 1), G.filename));
	1305	if (DosSetFSInfo(G.os2.nLabelDrive, FSIL_VOLSER, (PBYTE)&FSInfoBuf,
	1306	sizeof(VOLUMELABEL)))
	1307	{
	1308	Info(slide, 1, ((char *)slide, LoadFarString(ErrSetVolLabel)));
	1309	return 3;
	1310	}
	1311	return 2; /* success: skip the "extraction" quietly */
	1312	}
	1313
	1314	return error;
	1315
	1316	} /* end function mapname() */
	1317
	1318
	1319
	1320
	1321
	1322	/***********************/
	1323	/* Function checkdir() */
	1324	/***********************/
	1325
	1326	int checkdir(__G__ pathcomp, flag)
	1327	__GDEF
	1328	char *pathcomp;
	1329	int flag;
	1330	/*
	1331	* returns: 1 - (on APPEND_NAME) truncated filename
	1332	* 2 - path doesn't exist, not allowed to create
	1333	* 3 - path doesn't exist, tried to create and failed; or
	1334	* path exists and is not a directory, but is supposed to be
	1335	* 4 - path is too long
	1336	* 10 - can't allocate memory for filename buffers
	1337	*/
	1338	{
	1339	/* moved to os2data.h so they can be global */
	1340	#if 0
	1341	static int rootlen = 0; /* length of rootpath */
	1342	static char rootpath; / user's "extract-to" directory */
	1343	static char buildpathHPFS; / full path (so far) to extracted file, */
	1344	static char buildpathFAT; / both HPFS/EA (main) and FAT versions */
	1345	static char endHPFS; / corresponding pointers to end of */
	1346	static char endFAT; / buildpath ('\0') */
	1347	#endif
	1348
	1349	# define FN_MASK 7
	1350	# define FUNCTION (flag & FN_MASK)
	1351
	1352
	1353
	1354	/*---------------------------------------------------------------------------
	1355	APPEND_DIR: append the path component to the path being built and check
	1356	for its existence. If doesn't exist and we are creating directories, do
	1357	so for this one; else signal success or error as appropriate.
	1358	---------------------------------------------------------------------------*/
	1359
	1360	if (FUNCTION == APPEND_DIR) {
	1361	char *p = pathcomp;
	1362	int longdirEA, too_long=FALSE;
	1363
	1364	Trace((stderr, "appending dir segment [%s]\n", pathcomp));
	1365	while ((G.os2.endHPFS = p++) != '\0') /* copy to HPFS filename */
	1366	++G.os2.endHPFS;
	1367	if (IsFileNameValid(G.os2.buildpathHPFS)) {
	1368	longdirEA = FALSE;
	1369	p = pathcomp;
	1370	while ((G.os2.endFAT = p++) != '\0') /* copy to FAT filename, too */
	1371	++G.os2.endFAT;
	1372	} else {
	1373	longdirEA = TRUE;
	1374	/* GRR: check error return? */
	1375	map2fat(pathcomp, &G.os2.endFAT); /* map, put in FAT fn, update endFAT */
	1376	}
	1377
	1378	/* GRR: could do better check, see if overrunning buffer as we go:
	1379	* check endHPFS-G.os2.buildpathHPFS after each append, set warning variable
	1380	* if within 20 of FILNAMSIZ; then if var set, do careful check when
	1381	* appending. Clear variable when begin new path. */
	1382
	1383	/* next check: need to append '/', at least one-char name, '\0' */
	1384	if ((G.os2.endHPFS-G.os2.buildpathHPFS) > FILNAMSIZ-3)
	1385	too_long = TRUE; /* check if extracting dir? */
	1386	#ifdef MSC /* MSC 6.00 bug: stat(non-existent-dir) == 0 [exists!] */
	1387	if (GetFileTime(G.os2.buildpathFAT) == -1 \|\| stat(G.os2.buildpathFAT, &G.statbuf))
	1388	#else
	1389	if (stat(G.os2.buildpathFAT, &G.statbuf)) /* path doesn't exist */
	1390	#endif
	1391	{
	1392	if (!G.create_dirs) { /* told not to create (freshening) */
	1393	free(G.os2.buildpathHPFS);
	1394	free(G.os2.buildpathFAT);
	1395	return 2; /* path doesn't exist: nothing to do */
	1396	}
	1397	if (too_long) { /* GRR: should allow FAT extraction w/o EAs */
	1398	Info(slide, 1, ((char *)slide, LoadFarString(PathTooLong),
	1399	G.os2.buildpathHPFS));
	1400	free(G.os2.buildpathHPFS);
	1401	free(G.os2.buildpathFAT);
	1402	return 4; /* no room for filenames: fatal */
	1403	}
	1404	if (MKDIR(G.os2.buildpathFAT, 0777) == -1) { /* create the directory */
	1405	Info(slide, 1, ((char *)slide, LoadFarString(CantCreateDir),
	1406	G.os2.buildpathFAT, G.filename));
	1407	free(G.os2.buildpathHPFS);
	1408	free(G.os2.buildpathFAT);
	1409	return 3; /* path didn't exist, tried to create, failed */
	1410	}
	1411	G.os2.created_dir = TRUE;
	1412	/* only set EA if creating directory */
	1413	/* GRR: need trailing '/' before function call? */
	1414	if (longdirEA) {
	1415	#ifdef DEBUG
	1416	int e =
	1417	#endif
	1418	SetLongNameEA(G.os2.buildpathFAT, pathcomp);
	1419	Trace((stderr, "APPEND_DIR: SetLongNameEA() returns %d\n", e));
	1420	}
	1421	} else if (!S_ISDIR(G.statbuf.st_mode)) {
	1422	Info(slide, 1, ((char *)slide, LoadFarString(DirIsntDirectory),
	1423	G.os2.buildpathFAT, G.filename));
	1424	free(G.os2.buildpathHPFS);
	1425	free(G.os2.buildpathFAT);
	1426	return 3; /* path existed but wasn't dir */
	1427	}
	1428	if (too_long) {
	1429	Info(slide, 1, ((char *)slide, LoadFarString(PathTooLong),
	1430	G.os2.buildpathHPFS));
	1431	free(G.os2.buildpathHPFS);
	1432	free(G.os2.buildpathFAT);
	1433	return 4; /* no room for filenames: fatal */
	1434	}
	1435	*G.os2.endHPFS++ = '/';
	1436	*G.os2.endFAT++ = '/';
	1437	G.os2.endHPFS = G.os2.endFAT = '\0';
	1438	Trace((stderr, "buildpathHPFS now = [%s]\n", G.os2.buildpathHPFS));
	1439	Trace((stderr, "buildpathFAT now = [%s]\n", G.os2.buildpathFAT));
	1440	return 0;
	1441
	1442	} /* end if (FUNCTION == APPEND_DIR) */
	1443
	1444	/*---------------------------------------------------------------------------
	1445	GETPATH: copy full FAT path to the string pointed at by pathcomp (want
	1446	filename to reflect name used on disk, not EAs; if full path is HPFS,
	1447	buildpathFAT and buildpathHPFS will be identical). Also free both paths.
	1448	---------------------------------------------------------------------------*/
	1449
	1450	if (FUNCTION == GETPATH) {
	1451	Trace((stderr, "getting and freeing FAT path [%s]\n", G.os2.buildpathFAT));
	1452	Trace((stderr, "freeing HPFS path [%s]\n", G.os2.buildpathHPFS));
	1453	strcpy(pathcomp, G.os2.buildpathFAT);
	1454	free(G.os2.buildpathFAT);
	1455	free(G.os2.buildpathHPFS);
	1456	G.os2.buildpathHPFS = G.os2.buildpathFAT = G.os2.endHPFS = G.os2.endFAT = (char *)NULL;
	1457	return 0;
	1458	}
	1459
	1460	/*---------------------------------------------------------------------------
	1461	APPEND_NAME: assume the path component is the filename; append it and
	1462	return without checking for existence.
	1463	---------------------------------------------------------------------------*/
	1464
	1465	if (FUNCTION == APPEND_NAME) {
	1466	char *p = pathcomp;
	1467	int error = 0;
	1468
	1469	Trace((stderr, "appending filename [%s]\n", pathcomp));
	1470	while ((G.os2.endHPFS = p++) != '\0') { /* copy to HPFS filename */
	1471	++G.os2.endHPFS;
	1472	if ((G.os2.endHPFS-G.os2.buildpathHPFS) >= FILNAMSIZ) {
	1473	*--G.os2.endHPFS = '\0';
	1474	Info(slide, 1, ((char *)slide, LoadFarString(PathTooLongTrunc),
	1475	G.filename, G.os2.buildpathHPFS));
	1476	error = 1; /* filename truncated */
	1477	}
	1478	}
	1479
	1480	/* GRR: how can longnameEA ever be set before this point??? we don't want
	1481	* to save the original name to EAs if user renamed it, do we?
	1482	*
	1483	* if (!G.os2.longnameEA && ((G.os2.longnameEA = !IsFileNameValid(name)) != 0))
	1484	*/
	1485	if (G.pInfo->vollabel \|\| IsFileNameValid(G.os2.buildpathHPFS)) {
	1486	G.os2.longnameEA = FALSE;
	1487	p = pathcomp;
	1488	while ((G.os2.endFAT = p++) != '\0') /* copy to FAT filename, too */
	1489	++G.os2.endFAT;
	1490	} else {
	1491	G.os2.longnameEA = TRUE;
	1492	if ((G.os2.lastpathcomp = (char *)malloc(strlen(pathcomp)+1)) ==
	1493	(char *)NULL)
	1494	{
	1495	Info(slide, 1, ((char *)slide,
	1496	"checkdir warning: cannot save longname EA: out of memory\n"));
	1497	G.os2.longnameEA = FALSE;
	1498	error = 1; /* can't set .LONGNAME extended attribute */
	1499	} else /* used and freed in close_outfile() */
	1500	strcpy(G.os2.lastpathcomp, pathcomp);
	1501	map2fat(pathcomp, &G.os2.endFAT); /* map, put in FAT fn, update endFAT */
	1502	}
	1503	Trace((stderr, "buildpathHPFS: %s\nbuildpathFAT: %s\n",
	1504	G.os2.buildpathHPFS, G.os2.buildpathFAT));
	1505
	1506	return error; /* could check for existence, prompt for new name... */
	1507
	1508	} /* end if (FUNCTION == APPEND_NAME) */
	1509
	1510	/*---------------------------------------------------------------------------
	1511	INIT: allocate and initialize buffer space for the file currently being
	1512	extracted. If file was renamed with an absolute path, don't prepend the
	1513	extract-to path.
	1514	---------------------------------------------------------------------------*/
	1515
	1516	if (FUNCTION == INIT) {
	1517	Trace((stderr, "initializing buildpathHPFS and buildpathFAT to "));
	1518	if ((G.os2.buildpathHPFS = (char )malloc(G.os2.fnlen+G.os2.rootlen+1)) == (char )NULL)
	1519	return 10;
	1520	if ((G.os2.buildpathFAT = (char )malloc(G.os2.fnlen+G.os2.rootlen+1)) == (char )NULL) {
	1521	free(G.os2.buildpathHPFS);
	1522	return 10;
	1523	}
	1524	if (G.pInfo->vollabel) { /* use root or renamed path, but don't store */
	1525	/* GRR: for network drives, do strchr() and return IZ_VOL_LABEL if not [1] */
	1526	if (G.os2.renamed_fullpath && pathcomp[1] == ':')
	1527	G.os2.buildpathHPFS = (char)ToLower(pathcomp);
	1528	else if (!G.os2.renamed_fullpath && G.os2.rootlen > 1 && G.os2.rootpath[1] == ':')
	1529	G.os2.buildpathHPFS = (char)ToLower(G.os2.rootpath);
	1530	else {
	1531	ULONG lMap;
	1532	DosQueryCurrentDisk(&G.os2.nLabelDrive, &lMap);
	1533	*G.os2.buildpathHPFS = (char)(G.os2.nLabelDrive - 1 + 'a');
	1534	}
	1535	G.os2.nLabelDrive = G.os2.buildpathHPFS - 'a' + 1; / save for mapname() */
	1536	if (uO.volflag == 0 \|\| G.os2.buildpathHPFS < 'a' \|\| / no labels/bogus? */
	1537	(uO.volflag == 1 && !isfloppy(G.os2.nLabelDrive))) { /* -$: no fixed */
	1538	free(G.os2.buildpathHPFS);
	1539	free(G.os2.buildpathFAT);
	1540	return IZ_VOL_LABEL; /* skipping with message */
	1541	}
	1542	*G.os2.buildpathHPFS = '\0';
	1543	} else if (G.os2.renamed_fullpath) /* pathcomp = valid data */
	1544	strcpy(G.os2.buildpathHPFS, pathcomp);
	1545	else if (G.os2.rootlen > 0)
	1546	strcpy(G.os2.buildpathHPFS, G.os2.rootpath);
	1547	else
	1548	*G.os2.buildpathHPFS = '\0';
	1549	G.os2.endHPFS = G.os2.buildpathHPFS;
	1550	G.os2.endFAT = G.os2.buildpathFAT;
	1551	while ((G.os2.endFAT = G.os2.endHPFS) != '\0') {
	1552	++G.os2.endFAT;
	1553	++G.os2.endHPFS;
	1554	}
	1555	Trace((stderr, "[%s]\n", G.os2.buildpathHPFS));
	1556	return 0;
	1557	}
	1558
	1559	/*---------------------------------------------------------------------------
	1560	ROOT: if appropriate, store the path in rootpath and create it if neces-
	1561	sary; else assume it's a zipfile member and return. This path segment
	1562	gets used in extracting all members from every zipfile specified on the
	1563	command line. Note that under OS/2 and MS-DOS, if a candidate extract-to
	1564	directory specification includes a drive letter (leading "x:"), it is
	1565	treated just as if it had a trailing '/'--that is, one directory level
	1566	will be created if the path doesn't exist, unless this is otherwise pro-
	1567	hibited (e.g., freshening).
	1568	---------------------------------------------------------------------------*/
	1569
	1570	#if (!defined(SFX) \|\| defined(SFX_EXDIR))
	1571	if (FUNCTION == ROOT) {
	1572	Trace((stderr, "initializing root path to [%s]\n", pathcomp));
	1573	if (pathcomp == (char *)NULL) {
	1574	G.os2.rootlen = 0;
	1575	return 0;
	1576	}
	1577	if ((G.os2.rootlen = strlen(pathcomp)) > 0) {
	1578	int had_trailing_pathsep=FALSE, has_drive=FALSE, xtra=2;
	1579
	1580	if (isalpha(pathcomp[0]) && pathcomp[1] == ':')
	1581	has_drive = TRUE; /* drive designator */
	1582	if (pathcomp[G.os2.rootlen-1] == '/') {
	1583	pathcomp[--G.os2.rootlen] = '\0';
	1584	had_trailing_pathsep = TRUE;
	1585	}
	1586	if (has_drive && (G.os2.rootlen == 2)) {
	1587	if (!had_trailing_pathsep) /* i.e., original wasn't "x:/" */
	1588	xtra = 3; /* room for '.' + '/' + 0 at end of "x:" */
	1589	} else if (G.os2.rootlen > 0) { /* need not check "x:." and "x:/" */
	1590	#ifdef MSC /* MSC 6.00 bug: stat(non-existent-dir) == 0 [exists!] */
	1591	if (GetFileTime(pathcomp) == -1 \|\|
	1592	SSTAT(pathcomp, &G.statbuf) \|\| !S_ISDIR(G.statbuf.st_mode))
	1593	#else
	1594	if (SSTAT(pathcomp, &G.statbuf) \|\| !S_ISDIR(G.statbuf.st_mode))
	1595	#endif
	1596	{ /* path does not exist */
	1597	if (!G.create_dirs /* \|\| iswild(pathcomp) */
	1598	) {
	1599	G.os2.rootlen = 0;
	1600	return 2; /* treat as stored file */
	1601	}
	1602	/* create directory (could add loop here to scan pathcomp
	1603	* and create more than one level, but really necessary?) */
	1604	if (MKDIR(pathcomp, 0777) == -1) {
	1605	Info(slide, 1, ((char *)slide,
	1606	LoadFarString(CantCreateExtractDir), pathcomp));
	1607	G.os2.rootlen = 0; /* path didn't exist, tried to create, */
	1608	return 3; /* failed: file exists, or need 2+ levels */
	1609	}
	1610	}
	1611	}
	1612	if ((G.os2.rootpath = (char )malloc(G.os2.rootlen+xtra)) == (char )NULL) {
	1613	G.os2.rootlen = 0;
	1614	return 10;
	1615	}
	1616	strcpy(G.os2.rootpath, pathcomp);
	1617	if (xtra == 3) /* had just "x:", make "x:." */
	1618	G.os2.rootpath[G.os2.rootlen++] = '.';
	1619	G.os2.rootpath[G.os2.rootlen++] = '/';
	1620	G.os2.rootpath[G.os2.rootlen] = '\0';
	1621	Trace((stderr, "rootpath now = [%s]\n", G.os2.rootpath));
	1622	}
	1623	return 0;
	1624	}
	1625	#endif /* !SFX \|\| SFX_EXDIR */
	1626
	1627	/*---------------------------------------------------------------------------
	1628	END: free rootpath, immediately prior to program exit.
	1629	---------------------------------------------------------------------------*/
	1630
	1631	if (FUNCTION == END) {
	1632	Trace((stderr, "freeing rootpath\n"));
	1633	if (G.os2.rootlen > 0) {
	1634	free(G.os2.rootpath);
	1635	G.os2.rootlen = 0;
	1636	}
	1637	return 0;
	1638	}
	1639
	1640	return 99; /* should never reach */
	1641
	1642	} /* end function checkdir() */
	1643
	1644
	1645
	1646
	1647
	1648	/***********************/
	1649	/* Function isfloppy() / / more precisely, is it removable? */
	1650	/***********************/
	1651
	1652	static int isfloppy(nDrive)
	1653	int nDrive; /* 1 == A:, 2 == B:, etc. */
	1654	{
	1655	uch ParmList[1] = {0};
	1656	uch DataArea[1] = {0};
	1657	char Name[3];
	1658	HFILE handle;
	1659	#ifdef __32BIT__
	1660	ULONG rc;
	1661	ULONG action;
	1662	#else
	1663	USHORT rc;
	1664	USHORT action;
	1665	#endif
	1666
	1667
	1668	Name[0] = (char) (nDrive + 'A' - 1);
	1669	Name[1] = ':';
	1670	Name[2] = 0;
	1671
	1672	rc = DosOpen(Name, &handle, &action, 0L, FILE_NORMAL, FILE_OPEN,
	1673	OPEN_FLAGS_DASD \| OPEN_FLAGS_FAIL_ON_ERROR \|
	1674	OPEN_ACCESS_READONLY \| OPEN_SHARE_DENYNONE, 0L);
	1675
	1676	if (rc == ERROR_NOT_READY) /* must be removable */
	1677	return TRUE;
	1678	else if (rc) { /* other error: do default a/b heuristic instead */
	1679	Trace((stderr, "error in DosOpen(DASD): guessing...\n", rc));
	1680	return (nDrive == 1 \|\| nDrive == 2)? TRUE : FALSE;
	1681	}
	1682
	1683	rc = DosDevIOCtl(DataArea, sizeof(DataArea), ParmList, sizeof(ParmList),
	1684	DSK_BLOCKREMOVABLE, IOCTL_DISK, handle);
	1685	DosClose(handle);
	1686
	1687	if (rc) { /* again, just check for a/b */
	1688	Trace((stderr, "error in DosDevIOCtl category IOCTL_DISK, function "
	1689	"DSK_BLOCKREMOVABLE\n (rc = 0x%04x): guessing...\n", rc));
	1690	return (nDrive == 1 \|\| nDrive == 2)? TRUE : FALSE;
	1691	} else {
	1692	return DataArea[0] ? FALSE : TRUE;
	1693	}
	1694	} /* end function isfloppy() */
	1695
	1696
	1697
	1698
	1699
	1700	static int IsFileNameValid(const char *name)
	1701	{
	1702	HFILE hf;
	1703	#ifdef __32BIT__
	1704	ULONG uAction;
	1705	#else
	1706	USHORT uAction;
	1707	#endif
	1708
	1709	switch( DosOpen((PSZ) name, &hf, &uAction, 0, 0, FILE_OPEN,
	1710	OPEN_ACCESS_READONLY \| OPEN_SHARE_DENYNONE, 0) )
	1711	{
	1712	case ERROR_INVALID_NAME:
	1713	case ERROR_FILENAME_EXCED_RANGE:
	1714	return FALSE;
	1715	case NO_ERROR:
	1716	DosClose(hf);
	1717	default:
	1718	return TRUE;
	1719	}
	1720	}
	1721
	1722
	1723
	1724
	1725
	1726	/**********************/
	1727	/* Function map2fat() */
	1728	/**********************/
	1729
	1730	static void map2fat(pathcomp, pEndFAT)
	1731	char pathcomp, *pEndFAT;
	1732	{
	1733	char ppc = pathcomp; / variable pointer to pathcomp */
	1734	char pEnd = pEndFAT; /* variable pointer to buildpathFAT */
	1735	char pBegin = pEndFAT; /* constant pointer to start of this comp. */
	1736	char last_dot = (char )NULL; /* last dot not converted to underscore */
	1737	int dotname = FALSE; /* flag: path component begins with dot */
	1738	/* ("." and ".." don't count) */
	1739	register unsigned workch; /* hold the character being tested */
	1740
	1741
	1742	/* Only need check those characters which are legal in HPFS but not
	1743	* in FAT: to get here, must already have passed through mapname.
	1744	* (GRR: oops, small bug--if char was quoted, no longer have any
	1745	* knowledge of that.) Also must truncate path component to ensure
	1746	* 8.3 compliance...
	1747	*/
	1748	while ((workch = (uch)*ppc++) != 0) {
	1749	switch (workch) {
	1750	case '[': /* add '"' '+' ',' '=' ?? */
	1751	case ']':
	1752	pEnd++ = '_'; / convert brackets to underscores */
	1753	break;
	1754
	1755	case '.':
	1756	if (pEnd == pEndFAT) { / nothing appended yet... */
	1757	if (ppc == '\0') / don't bother appending a */
	1758	break; /* "./" component to the path */
	1759	else if (ppc == '.' && ppc[1] == '\0') { / "../" */
	1760	pEnd++ = '.'; / add first dot, unchanged... */
	1761	++ppc; /* skip second dot, since it will */
	1762	} else { /* be "added" at end of if-block */
	1763	pEnd++ = '_'; / FAT doesn't allow null filename */
	1764	dotname = TRUE; /* bodies, so map .exrc -> _.exrc */
	1765	} /* (extra '_' now, "dot" below) */
	1766	} else if (dotname) { /* found a second dot, but still */
	1767	dotname = FALSE; /* have extra leading underscore: */
	1768	pEnd = '\0'; / remove it by shifting chars */
	1769	pEnd = pEndFAT + 1; / left one space (e.g., .p1.p2: */
	1770	while (pEnd[1]) { /* __p1 -> _p1_p2 -> _p1.p2 when */
	1771	pEnd = pEnd[1]; / finished) [opt.: since first */
	1772	++pEnd; /* two chars are same, can start */
	1773	} /* shifting at second position] */
	1774	}
	1775	last_dot = pEnd; /* point at last dot so far... */
	1776	pEnd++ = '_'; / convert dot to underscore for now */
	1777	break;
	1778
	1779	default:
	1780	*pEnd++ = (char)workch;
	1781
	1782	} /* end switch */
	1783	} /* end while loop */
	1784
	1785	pEnd = '\0'; / terminate buildpathFAT */
	1786
	1787	/* NOTE: keep in mind that pEnd points to the end of the path
	1788	* component, and pEndFAT still points to the beginning* of it...
	1789	* Also note that the algorithm does not try to get too fancy:
	1790	* if there are no dots already, the name either gets truncated
	1791	* at 8 characters or the last underscore is converted to a dot
	1792	* (only if more characters are saved that way). In no case is
	1793	* a dot inserted between existing characters.
	1794	*/
	1795	if (last_dot == (char )NULL) { / no dots: check for underscores... */
	1796	char plu = strrchr(pBegin, '_'); / pointer to last underscore */
	1797
	1798	if (plu == (char )NULL) { / no dots, no underscores: truncate at 8 */
	1799	pEndFAT += 8; / chars (could insert '.' and keep 11...) */
	1800	if (*pEndFAT > pEnd)
	1801	pEndFAT = pEnd; / oops...didn't have 8 chars to truncate */
	1802	else
	1803	**pEndFAT = '\0';
	1804	} else if (MIN(plu - pBegin, 8) + MIN(pEnd - plu - 1, 3) > 8) {
	1805	last_dot = plu; /* be lazy: drop through to next if-block */
	1806	} else if ((pEnd - *pEndFAT) > 8) {
	1807	pEndFAT += 8; / more fits into just basename than if */
	1808	*pEndFAT = '\0'; / convert last underscore to dot */
	1809	} else
	1810	pEndFAT = pEnd; / whole thing fits into 8 chars or less */
	1811	}
	1812
	1813	if (last_dot != (char )NULL) { / one dot (or two, in the case of */
	1814	last_dot = '.'; / "..") is OK: put it back in */
	1815
	1816	if ((last_dot - pBegin) > 8) {
	1817	char p, q;
	1818	int i;
	1819
	1820	p = last_dot;
	1821	q = last_dot = pBegin + 8;
	1822	for (i = 0; (i < 4) && p; ++i) / too many chars in basename: */
	1823	q++ = p++; /* shift ".ext" left and */
	1824	q = '\0'; / truncate/terminate it */
	1825	*pEndFAT = q;
	1826	} else if ((pEnd - last_dot) > 4) { /* too many chars in extension */
	1827	*pEndFAT = last_dot + 4;
	1828	**pEndFAT = '\0';
	1829	} else
	1830	pEndFAT = pEnd; / filename is fine; point at terminating zero */
	1831
	1832	if ((last_dot - pBegin) > 0 && last_dot[-1] == ' ')
	1833	last_dot[-1] = '_'; /* NO blank in front of '.'! */
	1834	}
	1835	} /* end function map2fat() */
	1836
	1837
	1838
	1839
	1840
	1841	static int SetLongNameEA(char name, char longname)
	1842	{
	1843	EAOP eaop;
	1844	FEALST fealst;
	1845
	1846	eaop.fpFEAList = (PFEALIST) &fealst;
	1847	eaop.fpGEAList = NULL;
	1848	eaop.oError = 0;
	1849
	1850	strcpy((char *) fealst.szName, ".LONGNAME");
	1851	strcpy((char *) fealst.szValue, longname);
	1852
	1853	fealst.cbList = sizeof(fealst) - CCHMAXPATH + strlen((char *) fealst.szValue);
	1854	fealst.cbName = (BYTE) strlen((char *) fealst.szName);
	1855	fealst.cbValue = sizeof(USHORT) * 2 + strlen((char *) fealst.szValue);
	1856
	1857	#ifdef __32BIT__
	1858	fealst.oNext = 0;
	1859	#endif
	1860	fealst.fEA = 0;
	1861	fealst.eaType = 0xFFFD;
	1862	fealst.eaSize = strlen((char *) fealst.szValue);
	1863
	1864	return DosSetPathInfo(name, FIL_QUERYEASIZE,
	1865	(PBYTE) &eaop, sizeof(eaop), 0);
	1866	}
	1867
	1868
	1869
	1870
	1871
	1872	/****************************/
	1873	/* Function close_outfile() */
	1874	/****************************/
	1875
	1876	/* GRR: need to return error level!! */
	1877
	1878	void close_outfile(__G) /* only for extracted files, not directories */
	1879	__GDEF
	1880	{
	1881	fclose(G.outfile);
	1882
	1883	/* set extra fields, both stored-in-zipfile and .LONGNAME flavors */
	1884	if (G.extra_field) { /* zipfile extra field may have extended attribs */
	1885	int err = EvalExtraFields(__G__ G.filename, G.extra_field,
	1886	G.lrec.extra_field_length);
	1887
	1888	if (err == IZ_EF_TRUNC) {
	1889	if (uO.qflag)
	1890	Info(slide, 1, ((char *)slide, "%-22s ", G.filename));
	1891	Info(slide, 1, ((char *)slide, LoadFarString(TruncEAs),
	1892	makeword(G.extra_field+2)-10, uO.qflag? "\n" : ""));
	1893	}
	1894	}
	1895
	1896	if (G.os2.longnameEA) {
	1897	#ifdef DEBUG
	1898	int e =
	1899	#endif
	1900	SetLongNameEA(G.filename, G.os2.lastpathcomp);
	1901	Trace((stderr, "close_outfile: SetLongNameEA() returns %d\n", e));
	1902	free(G.os2.lastpathcomp);
	1903	}
	1904
	1905	/* set date/time and permissions */
	1906	SetPathAttrTimes(__G__ G.pInfo->file_attr, 0);
	1907
	1908	} /* end function close_outfile() */
	1909
	1910
	1911
	1912
	1913
	1914	/******************************/
	1915	/* Function check_for_newer() */
	1916	/******************************/
	1917
	1918	int check_for_newer(__G__ filename) /* return 1 if existing file newer or equal; */
	1919	__GDEF
	1920	char filename; / 0 if older; -1 if doesn't exist yet */
	1921	{
	1922	ulg existing, archive;
	1923	#ifdef USE_EF_UT_TIME
	1924	iztimes z_utime;
	1925	#endif
	1926
	1927	if ((existing = (ulg)GetFileTime(filename)) == (ulg)-1)
	1928	return DOES_NOT_EXIST;
	1929
	1930	#ifdef USE_EF_UT_TIME
	1931	if (G.extra_field &&
	1932	#ifdef IZ_CHECK_TZ
	1933	G.tz_is_valid &&
	1934	#endif
	1935	(ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
	1936	G.lrec.last_mod_dos_datetime, &z_utime, NULL)
	1937	& EB_UT_FL_MTIME))
	1938	{
	1939	TTrace((stderr, "check_for_newer: using Unix extra field mtime\n"));
	1940	archive = Utime2DosDateTime(z_utime.mtime);
	1941	} else {
	1942	archive = G.lrec.last_mod_dos_datetime;
	1943	}
	1944	#else /* !USE_EF_UT_TIME */
	1945	archive = G.lrec.last_mod_dos_datetime;
	1946	#endif /* ?USE_EF_UT_TIME */
	1947
	1948	return (existing >= archive);
	1949	} /* end function check_for_newer() */
	1950
	1951
	1952
	1953
	1954
	1955	#ifndef SFX
	1956
	1957	/*************************/
	1958	/* Function dateformat() */
	1959	/*************************/
	1960
	1961	int dateformat()
	1962	{
	1963	/*-----------------------------------------------------------------------------
	1964	For those operating systems which support it, this function returns a value
	1965	which tells how national convention says that numeric dates are displayed.
	1966	Return values are DF_YMD, DF_DMY and DF_MDY.
	1967	-----------------------------------------------------------------------------*/
	1968
	1969	switch (GetCountryInfo()) {
	1970	case 0:
	1971	return DF_MDY;
	1972	case 1:
	1973	return DF_DMY;
	1974	case 2:
	1975	return DF_YMD;
	1976	}
	1977	return DF_MDY; /* default if error */
	1978
	1979	} /* end function dateformat() */
	1980
	1981
	1982
	1983
	1984
	1985	/************************/
	1986	/* Function version() */
	1987	/************************/
	1988
	1989	void version(__G)
	1990	__GDEF
	1991	{
	1992	int len;
	1993	#if defined(__IBMC__) \|\| defined(__WATCOMC__) \|\| defined(_MSC_VER)
	1994	char buf[80];
	1995	#endif
	1996
	1997	len = sprintf((char *)slide, LoadFarString(CompiledWith),
	1998
	1999	#if defined(__GNUC__)
	2000	# ifdef __EMX__ /* __EMX__ is defined as "1" only (sigh) */
	2001	"emx+gcc ", __VERSION__,
	2002	# else
	2003	"gcc/2 ", __VERSION__,
	2004	# endif
	2005	#elif defined(__IBMC__)
	2006	"IBM ",
	2007	# if (__IBMC__ < 200)
	2008	(sprintf(buf, "C Set/2 %d.%02d", __IBMC__/100,__IBMC__%100), buf),
	2009	# elif (__IBMC__ < 300)
	2010	(sprintf(buf, "C Set++ %d.%02d", __IBMC__/100,__IBMC__%100), buf),
	2011	# else
	2012	(sprintf(buf, "Visual Age C++ %d.%02d", __IBMC__/100,__IBMC__%100), buf),
	2013	# endif
	2014	#elif defined(__WATCOMC__)
	2015	"Watcom C", (sprintf(buf, " (__WATCOMC__ = %d)", __WATCOMC__), buf),
	2016	#elif defined(__TURBOC__)
	2017	# ifdef __BORLANDC__
	2018	"Borland C++",
	2019	# if (__BORLANDC__ < 0x0460)
	2020	" 1.0",
	2021	# elif (__BORLANDC__ == 0x0460)
	2022	" 1.5", /* from Kai Uwe: three less than DOS */
	2023	# else
	2024	" 2.0", /* (__BORLANDC__ == 0x0500)? */
	2025	# endif
	2026	# else
	2027	"Turbo C", /* these are probably irrelevant */
	2028	# if (__TURBOC__ >= 661)
	2029	"++ 1.0 or later",
	2030	# elif (__TURBOC__ == 661)
	2031	" 3.0?",
	2032	# elif (__TURBOC__ == 397)
	2033	" 2.0",
	2034	# else
	2035	" 1.0 or 1.5?",
	2036	# endif
	2037	# endif
	2038	#elif defined(MSC)
	2039	"Microsoft C ",
	2040	# ifdef _MSC_VER
	2041	(sprintf(buf, "%d.%02d", _MSC_VER/100, _MSC_VER%100), buf),
	2042	# else
	2043	"5.1 or earlier",
	2044	# endif
	2045	#else
	2046	"unknown compiler", "",
	2047	#endif /* ?compilers */
	2048
	2049	"OS/2",
	2050
	2051	/* GRR: does IBM C/2 identify itself as IBM rather than Microsoft? */
	2052	#if (defined(MSC) \|\| (defined(__WATCOMC__) && !defined(__386__)))
	2053	# if defined(M_I86HM) \|\| defined(__HUGE__)
	2054	" (16-bit, huge)",
	2055	# elif defined(M_I86LM) \|\| defined(__LARGE__)
	2056	" (16-bit, large)",
	2057	# elif defined(M_I86MM) \|\| defined(__MEDIUM__)
	2058	" (16-bit, medium)",
	2059	# elif defined(M_I86CM) \|\| defined(__COMPACT__)
	2060	" (16-bit, compact)",
	2061	# elif defined(M_I86SM) \|\| defined(__SMALL__)
	2062	" (16-bit, small)",
	2063	# elif defined(M_I86TM) \|\| defined(__TINY__)
	2064	" (16-bit, tiny)",
	2065	# else
	2066	" (16-bit)",
	2067	# endif
	2068	#else
	2069	" 2.x/3.x (32-bit)",
	2070	#endif
	2071
	2072	#ifdef __DATE__
	2073	" on ", __DATE__
	2074	#else
	2075	"", ""
	2076	#endif
	2077	);
	2078
	2079	(G.message)((zvoid )&G, slide, (ulg)len, 0);
	2080	/* MSC can't handle huge macro expansions */
	2081
	2082	/* temporary debugging code for Borland compilers only */
	2083	/* __TCPLUSPLUS__, __BCPLUSPLUS__ not defined for v1.5 */
	2084	#if (defined(__TURBOC__) && defined(DEBUG))
	2085	Info(slide, 0, ((char *)slide, "\t(__TURBOC__ = 0x%04x = %d)\n", __TURBOC__,
	2086	__TURBOC__));
	2087	#ifdef __BORLANDC__
	2088	Info(slide, 0, ((char *)slide, "\t(__BORLANDC__ = 0x%04x)\n",__BORLANDC__));
	2089	#else
	2090	Info(slide, 0, ((char *)slide, "\tdebug(__BORLANDC__ not defined)\n"));
	2091	#endif
	2092	#endif /* __TURBOC__ && DEBUG */
	2093
	2094	} /* end function version() */
	2095
	2096	#endif /* !SFX */
	2097
	2098
	2099
	2100	/* This table can be static because it is pseudo-constant */
	2101	static unsigned char cUpperCase[256], cLowerCase[256];
	2102	static BOOL bInitialized=FALSE;
	2103
	2104	/* Initialize the tables of upper- and lowercase characters, including
	2105	handling of country-dependent characters. */
	2106
	2107	static void InitNLS(void)
	2108	{
	2109	unsigned nCnt, nU;
	2110	COUNTRYCODE cc;
	2111
	2112	if (bInitialized == FALSE) {
	2113	bInitialized = TRUE;
	2114
	2115	for ( nCnt = 0; nCnt < 256; nCnt++ )
	2116	cUpperCase[nCnt] = cLowerCase[nCnt] = (unsigned char) nCnt;
	2117
	2118	cc.country = cc.codepage = 0;
	2119	DosMapCase(sizeof(cUpperCase), &cc, (PCHAR) cUpperCase);
	2120
	2121	for ( nCnt = 0; nCnt < 256; nCnt++ ) {
	2122	nU = cUpperCase[nCnt];
	2123	if (nU != nCnt && cLowerCase[nU] == (unsigned char) nU)
	2124	cLowerCase[nU] = (unsigned char) nCnt;
	2125	}
	2126
	2127	for ( nCnt = 'A'; nCnt <= 'Z'; nCnt++ )
	2128	cLowerCase[nCnt] = (unsigned char) (nCnt - 'A' + 'a');
	2129	}
	2130	}
	2131
	2132
	2133	int IsUpperNLS(int nChr)
	2134	{
	2135	return (cUpperCase[nChr] == (unsigned char) nChr);
	2136	}
	2137
	2138
	2139	int ToLowerNLS(int nChr)
	2140	{
	2141	return cLowerCase[nChr];
	2142	}
	2143
	2144
	2145	char StringLower(char szArg)
	2146	{
	2147	unsigned char *szPtr;
	2148
	2149	for ( szPtr = (unsigned char ) szArg; szPtr; szPtr++ )
	2150	szPtr = cLowerCase[szPtr];
	2151	return szArg;
	2152	}
	2153
	2154
	2155	#if defined(__IBMC__) && defined(__DEBUG_ALLOC__)
	2156	void DebugMalloc(void)
	2157	{
	2158	_dump_allocated(0); /* print out debug malloc memory statistics */
	2159	}
	2160	#endif
	2161
	2162
	2163	#if defined(REENTRANT) && defined(USETHREADID)
	2164	ulg GetThreadId(void)
	2165	{
	2166	PTIB pptib; /* Address of a pointer to the
	2167	Thread Information Block */
	2168	PPIB pppib; /* Address of a pointer to the
	2169	Process Information Block */
	2170
	2171	DosGetInfoBlocks(&pptib, &pppib);
	2172	return pptib->tib_ptib2->tib2_ultid;
	2173	}
	2174	#endif /* defined(REENTRANT) && defined(USETHREADID) */
	2175
	2176
	2177	void os2GlobalsCtor(__GPRO)
	2178	{
	2179	G.os2.nLastDrive = (USHORT)(-1);
	2180	G.os2.firstcall = TRUE;
	2181
	2182	#ifdef OS2DLL
	2183	G.os2.rexx_mes = "0";
	2184	#endif
	2185
	2186	InitNLS();
	2187	}