Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

dosh.c

Visit:

Last change on this file was 413, checked in by pr, 13 years ago
Fix buffer overwrite. Bug 1206.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 153.9 KB

Rev	Line
[8]	1
	2	/*
	3	*@@sourcefile dosh.c:
	4	* dosh.c contains Control Program helper functions.
	5	*
	6	* This file has miscellaneous system functions,
	7	* drive helpers, file helpers, and partition functions.
	8	*
	9	* Usage: All OS/2 programs.
	10	*
	11	* Function prefixes (new with V0.81):
	12	* -- dosh* Dos (Control Program) helper functions
	13	*
	14	* These funcs are forward-declared in dosh.h, which
	15	* must be #include'd first.
	16	*
	17	* The resulting dosh.obj object file can be linked
	18	* against any application object file. As opposed to
	19	* the code in dosh2.c, it does not require any other
	20	* code from the helpers.
	21	*
	22	* dosh.obj can also be used with the VAC subsystem
	23	* library (/rn compiler option).
	24	*
	25	* Note: Version numbering in this file relates to XWorkplace version
	26	* numbering.
	27	*
	28	*@@header "helpers\dosh.h"
	29	*/
	30
	31	/*
[411]	32	* This file Copyright (C) 1997-2012 Ulrich Mller.
[14]	33	* This file is part of the "XWorkplace helpers" source package.
	34	* This is free software; you can redistribute it and/or modify
[8]	35	* it under the terms of the GNU General Public License as published
	36	* by the Free Software Foundation, in version 2 as it comes in the
	37	* "COPYING" file of the XWorkplace main distribution.
	38	* This program is distributed in the hope that it will be useful,
	39	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	41	* GNU General Public License for more details.
	42	*/
	43
	44	#define OS2EMX_PLAIN_CHAR
	45	// this is needed for "os2emx.h"; if this is defined,
	46	// emx will define PSZ as _signed_ char, otherwise
	47	// as unsigned char
	48
[14]	49	#define INCL_DOSMODULEMGR
	50	#define INCL_DOSPROCESS
[135]	51	#define INCL_DOSEXCEPTIONS
[14]	52	#define INCL_DOSSESMGR
	53	#define INCL_DOSQUEUES
[113]	54	#define INCL_DOSSEMAPHORES
[14]	55	#define INCL_DOSMISC
	56	#define INCL_DOSDEVICES
[8]	57	#define INCL_DOSDEVIOCTL
	58	#define INCL_DOSERRORS
[14]	59
[8]	60	#define INCL_KBD
	61	#include <os2.h>
[14]	62
[8]	63	#include <stdlib.h>
	64	#include <string.h>
	65	#include <stdio.h>
[113]	66	#include <stdarg.h>
[116]	67	#include <ctype.h>
[8]	68
	69	#include "setup.h" // code generation and debugging options
	70
	71	#include "helpers\dosh.h"
[113]	72	#include "helpers\standards.h"
[8]	73
	74	#pragma hdrstop
	75
[108]	76	// static const CHAR G_acDriveLetters[28] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
[8]	77
	78	/*
[135]	79	*@@category: Helpers\Control program helpers\Wrappers
	80	*/
	81
	82	/* ******************************************************************
	83	*
	84	* Wrappers
	85	*
	86	********************************************************************/
	87
	88	#ifdef DOSH_STANDARDWRAPPERS
	89
	90	/*
	91	*@@ doshSleep:
	92	*
	93	*@@added V0.9.16 (2002-01-26) [umoeller]
	94	*/
	95
	96	APIRET doshSleep(ULONG msec)
	97	{
	98	// put the call in brackets so the macro won't apply here
	99	return (DosSleep)(msec);
	100	}
	101
	102	/*
	103	*@@ doshCreateMutexSem:
	104	*
	105	*@@added V0.9.16 (2002-01-26) [umoeller]
	106	*/
	107
	108	APIRET doshCreateMutexSem(PSZ pszName,
	109	PHMTX phmtx,
	110	ULONG flAttr,
	111	BOOL32 fState)
	112	{
	113	// put the call in brackets so the macro won't apply here
	114	return (DosCreateMutexSem)(pszName, phmtx, flAttr, fState);
	115	}
	116
	117	/*
	118	*@@ doshRequestMutexSem:
	119	*
	120	*@@added V0.9.16 (2002-01-26) [umoeller]
	121	*/
	122
	123	APIRET doshRequestMutexSem(HMTX hmtx, ULONG ulTimeout)
	124	{
	125	return (DosRequestMutexSem)(hmtx, ulTimeout);
	126	}
	127
	128	/*
	129	*@@ doshReleaseMutexSem:
	130	*
	131	*@@added V0.9.16 (2002-01-26) [umoeller]
	132	*/
	133
	134	APIRET doshReleaseMutexSem(HMTX hmtx)
	135	{
	136	return (DosReleaseMutexSem)(hmtx);
	137	}
	138
	139	/*
	140	*@@ doshSetExceptionHandler:
	141	*
	142	*@@added V0.9.16 (2002-01-26) [umoeller]
	143	*/
	144
	145	APIRET doshSetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD pERegRec)
	146	{
	147	// put the call in brackets so the macro won't apply here
	148	return (DosSetExceptionHandler)(pERegRec);
	149	}
	150
	151	/*
	152	*@@ doshUnsetExceptionHandler:
	153	*
	154	*@@added V0.9.16 (2002-01-26) [umoeller]
	155	*/
	156
	157	APIRET doshUnsetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD pERegRec)
	158	{
	159	// put the call in brackets so the macro won't apply here
	160	return (DosUnsetExceptionHandler)(pERegRec);
	161	}
	162
	163	#endif
	164
	165	/*
[8]	166	*@@category: Helpers\Control program helpers\Miscellaneous
[21]	167	* Miscellaneous helpers in dosh.c that didn't fit into any other
	168	* category.
[8]	169	*/
	170
	171	/* ******************************************************************
[14]	172	*
	173	* Miscellaneous
	174	*
[8]	175	********************************************************************/
	176
	177	/*
	178	*@@ doshGetChar:
	179	* reads a single character from the keyboard.
	180	* Useful for VIO sessions, since there's great
	181	* confusion between the various C dialects about
	182	* how to use getc(), and getc() doesn't work
	183	* with the VAC subsystem library.
	184	*
	185	*@@added V0.9.4 (2000-07-27) [umoeller]
	186	*/
	187
	188	CHAR doshGetChar(VOID)
	189	{
	190	// CHAR c;
	191	// ULONG ulRead = 0;
	192
	193	KBDKEYINFO kki;
	194	KbdCharIn(&kki,
	195	0, // wait
	196	0);
	197
[238]	198	return kki.chChar;
[8]	199	}
	200
	201	/*
	202	*@@ doshQueryShiftState:
	203	* returns TRUE if any of the SHIFT keys are
	204	* currently pressed. Useful for checks during
	205	* WM_COMMAND messages from menus.
	206	*
	207	*@@changed V0.9.5 (2000-09-27) [umoeller]: added error checking
	208	*/
	209
	210	BOOL doshQueryShiftState(VOID)
	211	{
	212	BOOL brc = FALSE;
	213	APIRET arc = NO_ERROR;
	214	HFILE hfKbd;
	215	ULONG ulAction;
	216
[123]	217	if (!(arc = DosOpen("KBD$", &hfKbd, &ulAction, 0,
	218	FILE_NORMAL,
	219	FILE_OPEN,
	220	OPEN_ACCESS_READONLY \| OPEN_SHARE_DENYWRITE,
	221	(PEAOP2)NULL)))
[8]	222	{
	223	SHIFTSTATE ShiftState;
	224	ULONG cbDataLen = sizeof(ShiftState);
	225
[123]	226	if (!(arc = DosDevIOCtl(hfKbd, IOCTL_KEYBOARD, KBD_GETSHIFTSTATE,
	227	NULL, 0, NULL, // no parameters
	228	&ShiftState, cbDataLen, &cbDataLen)))
[8]	229	brc = ((ShiftState.fsState & 3) != 0);
	230
	231	DosClose(hfKbd);
	232	}
	233
	234	return brc;
	235	}
	236
	237	/*
	238	*@@ doshQuerySysErrorMsg:
	239	* this retrieves the error message for a system error
	240	* (APIRET) from the system error message file (OSO001.MSG).
	241	* This file better be on the DPATH (it normally is).
	242	*
	243	* This returns the string in the "SYSxxx: blahblah" style,
	244	* which is normally displayed on the command line when
	245	* errors occur.
	246	*
	247	* The error message is returned in a newly allocated
	248	* buffer, which should be free()'d afterwards.
	249	*
[229]	250	* The returned string is properly null-terminated but
	251	* should not end with a line break (\r or \n) if I see
	252	* this correctly.
	253	*
[8]	254	* Returns NULL upon errors.
[229]	255	*
	256	*@@changed V1.0.0 (2002-09-24) [umoeller]: now supporting NET messages as well
[8]	257	*/
	258
	259	PSZ doshQuerySysErrorMsg(APIRET arc) // in: DOS error code
	260	{
[229]	261	PSZ pszReturn = NULL;
[8]	262	CHAR szDosError[1000];
	263	ULONG cbDosError = 0;
[229]	264	PCSZ pcszMsgFile;
	265
	266	if ( (arc >= 2100)
	267	&& (arc <= 8000)
	268	)
	269	pcszMsgFile = "NET.MSG";
	270	else
	271	pcszMsgFile = "OSO001.MSG"; // default OS/2 message file
	272
	273	if (!DosGetMessage(NULL, 0, // no string replacements
	274	szDosError, sizeof(szDosError),
	275	arc,
	276	(PSZ)pcszMsgFile,
	277	&cbDosError))
[8]	278	{
	279	szDosError[cbDosError - 2] = 0;
	280	pszReturn = strdup(szDosError);
	281	}
[229]	282
	283	return pszReturn;
[8]	284	}
	285
	286	/*
[69]	287	*@@ doshQuerySysUptime:
	288	* returns the system uptime in milliseconds.
	289	* This can be used for time comparisons.
	290	*
	291	*@@added V0.9.12 (2001-05-18) [umoeller]
	292	*/
	293
	294	ULONG doshQuerySysUptime(VOID)
	295	{
	296	ULONG ulms;
	297	DosQuerySysInfo(QSV_MS_COUNT,
	298	QSV_MS_COUNT,
	299	&ulms,
	300	sizeof(ulms));
[238]	301	return ulms;
[69]	302	}
	303
	304	/*
[81]	305	*@@ doshDevIOCtl:
	306	*
	307	* Works with those IOCtls where the buffer
	308	* size parameters are always the same anyway,
	309	* which applies to all IOCtls I have seen
	310	* so far.
	311	*
	312	*@@added V0.9.13 (2001-06-14) [umoeller]
	313	*/
	314
	315	APIRET doshDevIOCtl(HFILE hf,
	316	ULONG ulCategory,
	317	ULONG ulFunction,
	318	PVOID pvParams,
	319	ULONG cbParams,
	320	PVOID pvData,
	321	ULONG cbData)
	322	{
[238]	323	return DosDevIOCtl(hf,
	324	ulCategory,
	325	ulFunction,
	326	pvParams, cbParams, &cbParams,
	327	pvData, cbData, &cbData);
[81]	328	}
	329
	330	/*
[21]	331	*@@category: Helpers\Control program helpers\Shared memory management
	332	* helpers for allocating and requesting shared memory.
[8]	333	*/
	334
	335	/* ******************************************************************
[14]	336	*
	337	* Memory helpers
	338	*
[8]	339	********************************************************************/
	340
	341	/*
[133]	342	*@@ doshMalloc:
[113]	343	* wrapper around malloc() which automatically
	344	* sets ERROR_NOT_ENOUGH_MEMORY.
	345	*
	346	*@@added V0.9.16 (2001-10-19) [umoeller]
	347	*/
	348
	349	PVOID doshMalloc(ULONG cb,
	350	APIRET *parc)
	351	{
	352	PVOID pv;
	353	*parc = NO_ERROR;
	354	if (!(pv = malloc(cb)))
	355	*parc = ERROR_NOT_ENOUGH_MEMORY;
	356
[238]	357	return pv;
[113]	358	}
	359
	360	/*
[123]	361	*@@ doshAllocArray:
	362	* allocates c * cbArrayItem bytes.
	363	* Similar to calloc(), but returns
	364	* error codes:
	365	*
	366	* -- NO_ERROR: ppv and pcbAllocated were set.
	367	*
	368	* -- ERROR_NO_DATA: either c or cbArrayItem are
	369	* zero.
	370	*
	371	* -- ERROR_NOT_ENOUGH_MEMORY: malloc() failed.
	372	*
	373	*@@added V0.9.16 (2001-12-08) [umoeller]
	374	*/
	375
	376	APIRET doshAllocArray(ULONG c, // in: array item count
	377	ULONG cbArrayItem, // in: size of one array item
	378	PBYTE *ppv, // out: memory ptr if NO_ERROR is returned
	379	PULONG pcbAllocated) // out: # of bytes allocated
	380	{
	381	if (!c \|\| !cbArrayItem)
	382	return ERROR_NO_DATA;
	383
	384	pcbAllocated = c cbArrayItem;
[126]	385	if (!(ppv = (PBYTE)malloc(pcbAllocated)))
[123]	386	return ERROR_NOT_ENOUGH_MEMORY;
	387
	388	return NO_ERROR;
	389	}
	390
	391	/*
[8]	392	*@@ doshAllocSharedMem:
	393	* wrapper for DosAllocSharedMem which has
	394	* a malloc()-like syntax. Just due to my
	395	* lazyness.
	396	*
	397	* Note that ulSize is always rounded up to the
	398	* next 4KB value, so don't use this hundreds of times.
	399	*
	400	* Returns NULL upon errors. Possible errors include
	401	* that a memory block calle pcszName has already been
	402	* allocated.
	403	*
	404	* Use DosFreeMem(pvrc) to free the memory. The memory
	405	* will only be freed if no other process has requested
	406	* access.
	407	*
	408	*@@added V0.9.3 (2000-04-18) [umoeller]
	409	*/
	410
	411	PVOID doshAllocSharedMem(ULONG ulSize, // in: requested mem block size (rounded up to 4KB)
	412	const char* pcszName) // in: name of block ("\\SHAREMEM\\xxx") or NULL
	413	{
	414	PVOID pvrc = NULL;
	415
[238]	416	if (!DosAllocSharedMem((PVOID*)&pvrc,
	417	(PSZ)pcszName,
	418	ulSize,
	419	PAG_COMMIT \| PAG_READ \| PAG_WRITE))
	420	return pvrc;
	421
[169]	422	return NULL;
[8]	423	}
	424
	425	/*
	426	*@@ doshRequestSharedMem:
	427	* requests access to a block of named shared memory
	428	* allocated by doshAllocSharedMem.
	429	*
	430	* Returns NULL upon errors.
	431	*
	432	* Use DosFreeMem(pvrc) to free the memory. The memory
	433	* will only be freed if no other process has requested
	434	* access.
	435	*
	436	*@@added V0.9.3 (2000-04-19) [umoeller]
	437	*/
	438
[116]	439	PVOID doshRequestSharedMem(PCSZ pcszName)
[8]	440	{
	441	PVOID pvrc = NULL;
	442
[238]	443	if (!DosGetNamedSharedMem((PVOID*)pvrc,
	444	(PSZ)pcszName,
	445	PAG_READ \| PAG_WRITE))
	446	return pvrc;
	447
[169]	448	return NULL;
[8]	449	}
	450
	451	/*
	452	*@@category: Helpers\Control program helpers\Drive management
[21]	453	* functions for managing drives... enumerating, testing,
	454	* querying etc.
[8]	455	*/
	456
	457	/* ******************************************************************
[14]	458	*
	459	* Drive helpers
	460	*
[8]	461	********************************************************************/
	462
	463	/*
[81]	464	*@@ doshIsFixedDisk:
	465	* checks whether a disk is fixed or removeable.
	466	* ulLogicalDrive must be 1 for drive A:, 2 for B:, ...
	467	* The result is stored in *pfFixed.
	468	* Returns DOS error code.
	469	*
	470	* From my testing, this function does _not_ provoke
	471	* "drive not ready" popups, even if the disk is not
	472	* ready.
	473	*
	474	* Warning: This uses DosDevIOCtl, which has proved
	475	* to cause problems with some device drivers for
	476	* removeable disks.
[94]	477	*
[135]	478	* Returns:
	479	*
	480	* -- NO_ERROR: *pfFixed was set.
	481	*
	482	* -- ERROR_INVALID_DRIVE: drive letter invalid
	483	*
	484	* -- ERROR_NOT_SUPPORTED (50): for network drives.
	485	*
[94]	486	*@@changed V0.9.14 (2001-08-03) [umoeller]: added extra fix for A: and B:
[81]	487	*/
	488
[91]	489	APIRET doshIsFixedDisk(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	490	PBOOL pfFixed) // out: TRUE for fixed disks
[81]	491	{
	492	APIRET arc = ERROR_INVALID_DRIVE;
	493
[94]	494	if ( (ulLogicalDrive == 1)
	495	\|\| (ulLogicalDrive == 2)
	496	)
	497	{
	498	// drive A: and B: can never be fixed V0.9.14 (2001-08-03) [umoeller]
	499	*pfFixed = FALSE;
	500	return NO_ERROR;
	501	}
	502
[81]	503	if (ulLogicalDrive)
	504	{
	505	// parameter packet
	506	#pragma pack(1)
	507	struct {
	508	UCHAR command,
	509	drive;
	510	} parms;
	511	#pragma pack()
	512
	513	// data packet
	514	UCHAR ucNonRemoveable;
	515
[133]	516	parms.drive = (UCHAR)(ulLogicalDrive - 1);
	517	if (!(arc = doshDevIOCtl((HFILE)-1,
	518	IOCTL_DISK, // 0x08
	519	DSK_BLOCKREMOVABLE, // 0x20
	520	&parms, sizeof(parms),
	521	&ucNonRemoveable, sizeof(ucNonRemoveable))))
[81]	522	*pfFixed = (BOOL)ucNonRemoveable;
	523	}
	524
[167]	525	return arc;
[81]	526	}
	527
	528	/*
	529	*@@ doshQueryDiskParams:
	530	* this retrieves more information about a given drive,
	531	* which is stored in the specified BIOSPARAMETERBLOCK
	532	* structure.
	533	*
	534	* BIOSPARAMETERBLOCK is defined in the Toolkit headers,
	535	* and from my testing, it's the same with the Toolkits
	536	* 3 and 4.5.
	537	*
	538	* If NO_ERROR is returned, the bDeviceType field can
	539	* be one of the following (according to CPREF):
	540	*
	541	* -- 0: 48 TPI low-density diskette drive
	542	* -- 1: 96 TPI high-density diskette drive
	543	* -- 2: 3.5-inch 720KB diskette drive
	544	* -- 3: 8-Inch single-density diskette drive
	545	* -- 4: 8-Inch double-density diskette drive
	546	* -- 5: Fixed disk
	547	* -- 6: Tape drive
	548	* -- 7: Other (includes 1.44MB 3.5-inch diskette drive)
	549	* -- 8: R/W optical disk
	550	* -- 9: 3.5-inch 4.0MB diskette drive (2.88MB formatted)
	551	*
	552	* From my testing, this function does _not_ provoke
	553	* "drive not ready" popups, even if the disk is not
	554	* ready.
	555	*
	556	* Warning: This uses DosDevIOCtl, which has proved
	557	* to cause problems with some device drivers for
	558	* removeable disks.
	559	*
	560	* This returns the DOS error code of DosDevIOCtl.
[133]	561	* This will be:
[81]	562	*
[133]	563	* -- NO_ERROR for all local disks;
	564	*
	565	* -- ERROR_NOT_SUPPORTED (50) for network drives.
	566	*
[81]	567	*@@added V0.9.0 [umoeller]
	568	*@@changed V0.9.13 (2001-06-14) [umoeller]: changed prototype to use BIOSPARAMETERBLOCK directly
	569	*@@changed V0.9.13 (2001-06-14) [umoeller]: now querying standard media, no redetermine
	570	*/
	571
	572	APIRET doshQueryDiskParams(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	573	PBIOSPARAMETERBLOCK pdp) // out: drive parameters
	574	{
	575	APIRET arc = ERROR_INVALID_DRIVE;
	576
	577	if (ulLogicalDrive)
	578	{
	579	#pragma pack(1)
	580	// parameter packet
	581	struct {
	582	UCHAR ucCommand,
	583	ucDrive;
	584	} parms;
	585	#pragma pack()
	586
	587	parms.ucCommand = 0; // 0 = return standard media,
	588	// 1 = read currently inserted media
	589	// (1 doesn't work any more, returns arc 87
	590	// V0.9.13 (2001-06-14) [umoeller])
	591	parms.ucDrive=(UCHAR)(ulLogicalDrive-1);
	592
	593	// zero the structure V0.9.13 (2001-06-14) [umoeller]
	594	memset(pdp, 0, sizeof(BIOSPARAMETERBLOCK));
	595
	596	arc = doshDevIOCtl((HFILE)-1,
[94]	597	IOCTL_DISK, // 0x08
	598	DSK_GETDEVICEPARAMS, // 0x63
[81]	599	&parms, sizeof(parms),
	600	pdp, sizeof(BIOSPARAMETERBLOCK));
	601
[82]	602	/* if (!arc)
[81]	603	{
	604	_Pmpf((" bDeviceType: %d", pdp->bDeviceType));
	605	_Pmpf((" bytes per sector: %d", pdp->usBytesPerSector));
	606	_Pmpf((" sectors per track: %d", pdp->usSectorsPerTrack));
[82]	607	} */
[81]	608	}
	609
[167]	610	return arc;
[81]	611	}
	612
	613	/*
[135]	614	*@@ doshQueryDriveType:
[81]	615	* tests the specified BIOSPARAMETERBLOCK
[133]	616	* for whether it represents a CD-ROM or
	617	* some other removeable drive type.
[81]	618	*
[133]	619	* Returns one of:
	620	*
[135]	621	* -- DRVTYPE_HARDDISK (0)
[133]	622	*
[135]	623	* -- DRVTYPE_PARTITIONABLEREMOVEABLE
	624	*
[133]	625	* -- DRVTYPE_CDROM
	626	*
[135]	627	* -- DRVTYPE_TAPE
[133]	628	*
[135]	629	* -- DRVTYPE_VDISK
	630	*
	631	* -- DRVTYPE_FLOPPY
	632	*
	633	* -- DRVTYPE_UNKNOWN (255)
	634	*
[81]	635	* The BIOSPARAMETERBLOCK must be filled
	636	* first using doshQueryDiskParams.
	637	*
[133]	638	*@@added V0.9.16 (2002-01-13) [umoeller]
[81]	639	*/
	640
[135]	641	BYTE doshQueryDriveType(ULONG ulLogicalDrive,
	642	PBIOSPARAMETERBLOCK pdp,
	643	BOOL fFixed)
[81]	644	{
[133]	645	if (pdp)
	646	{
[135]	647	if (pdp->fsDeviceAttr & DEVATTR_PARTITIONALREMOVEABLE) // 0x08
[220]	648	return DRVTYPE_PRT;
	649
	650	if (fFixed)
[135]	651	return DRVTYPE_HARDDISK;
[220]	652
	653	if ( (pdp->bDeviceType == 7) // "other"
	654	&& (pdp->usBytesPerSector == 2048)
	655	&& (pdp->usSectorsPerTrack == (USHORT)-1)
	656	)
	657	return DRVTYPE_CDROM;
	658
	659	switch (pdp->bDeviceType)
[135]	660	{
	661	case DEVTYPE_TAPE: // 6
	662	return DRVTYPE_TAPE;
	663
	664	case DEVTYPE_48TPI: // 0, 360k 5.25" floppy
	665	case DEVTYPE_96TPI: // 1, 1.2M 5.25" floppy
	666	case DEVTYPE_35: // 2, 720k 3.5" floppy
	667	case DEVTYPE_OTHER: // 7, 1.44 3.5" floppy
	668	// 1.84M 3.5" floppy
	669	case DEVTYPE_35_288MB:
	670	if ( (ulLogicalDrive == 1)
	671	\|\| (ulLogicalDrive == 2)
	672	)
	673	return DRVTYPE_FLOPPY;
	674
[220]	675	return DRVTYPE_VDISK;
	676
[135]	677	case DEVTYPE_RWOPTICAL: // 8, what is this?!?
	678	return DRVTYPE_FLOPPY;
	679	}
[133]	680	}
	681
[220]	682	return DRVTYPE_UNKNOWN;
[81]	683	}
	684
	685	/*
[220]	686	*@@ doshQueryCDDrives:
	687	* returns the no. of CD-ROM drives on the system
	688	* as well as the drive letter of the first
	689	* CD-ROM drive.
	690	*
[229]	691	*@@added V1.0.0 (2002-08-31) [umoeller]
[220]	692	*/
	693
	694	APIRET doshQueryCDDrives(PBYTE pcCDs, // out: CD-ROM drives count
	695	PCHAR pcFirstCD) // out: drive letter of first CD
	696	{
	697	APIRET arc;
	698	HFILE hfCDROM;
	699	ULONG ulAction;
	700
	701	if (!(arc = DosOpen("\\DEV\\CD-ROM2$",
	702	&hfCDROM,
	703	&ulAction,
	704	0,
	705	FILE_NORMAL,
	706	OPEN_ACTION_OPEN_IF_EXISTS,
	707	OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READONLY,
	708	NULL)))
	709	{
	710	struct
	711	{
	712	USHORT cCDs;
	713	USHORT usFirstCD; // 0 == A:, 1 == B:, ...
	714	} cdinfo;
	715
	716	ULONG cb = sizeof(cdinfo);
	717
	718	if (!(arc = DosDevIOCtl(hfCDROM,
	719	0x82,
	720	0x60,
	721	NULL,
	722	0,
	723	NULL,
	724	&cdinfo,
	725	cb,
	726	&cb)))
	727	{
	728	*pcCDs = cdinfo.cCDs;
	729	*pcFirstCD = cdinfo.usFirstCD + 'A';
	730	}
	731
	732	DosClose(hfCDROM);
	733	}
	734
	735	return arc;
	736	}
	737
	738	/*
	739	*@@ doshOpenDrive:
	740	* opens the given logical drive using
	741	* DosOpen with OPEN_FLAGS_DASD. Use
	742	* the file handle returned from here
	743	* for doshHasAudioCD and doshQueryCDStatus.
	744	*
	745	* If NO_ERROR is returned, use DosClose
	746	* to close the device again.
	747	*
[229]	748	*@@added V1.0.0 (2002-08-31) [umoeller]
[220]	749	*/
	750
	751	APIRET doshOpenDrive(ULONG ulLogicalDrive,
	752	HFILE *phf) // out: open drive's file handle
	753	{
	754	ULONG dummy;
	755
	756	CHAR szDrive[] = "C:";
	757	szDrive[0] = 'A' + ulLogicalDrive - 1;
	758
	759	return DosOpen(szDrive, // "C:", "D:", ...
	760	phf,
	761	&dummy,
	762	0,
	763	FILE_NORMAL,
	764	// OPEN_ACTION_FAIL_IF_NEW
	765	OPEN_ACTION_OPEN_IF_EXISTS,
	766	OPEN_FLAGS_DASD
	767	\| OPEN_FLAGS_FAIL_ON_ERROR
	768	// ^^^ if this flag is not set, we get the white
	769	// hard-error box
	770	\| OPEN_FLAGS_NOINHERIT // V0.9.6 (2000-11-25) [pr]
	771	// \| OPEN_ACCESS_READONLY // V0.9.13 (2001-06-14) [umoeller]
	772	\| OPEN_SHARE_DENYNONE,
	773	NULL);
	774	}
	775
	776	/*
[91]	777	*@@ doshHasAudioCD:
	778	* sets *pfAudio to whether ulLogicalDrive
	779	* currently has an audio CD inserted.
	780	*
	781	* Better call this only if you're sure that
	782	* ulLogicalDrive is a CD-ROM drive. Use
[133]	783	* doshQueryRemoveableType to check.
[91]	784	*
	785	*@@added V0.9.14 (2001-08-01) [umoeller]
[229]	786	*@@changed V1.0.0 (2002-08-31) [umoeller]: removed ulLogicalDrive which was not needed
[91]	787	*/
	788
[220]	789	APIRET doshHasAudioCD(HFILE hfDrive, // in: DASD open
[91]	790	BOOL fMixedModeCD,
	791	PBOOL pfAudio)
	792	{
	793	APIRET arc = NO_ERROR;
	794
[94]	795	ULONG ulAudioTracks = 0,
	796	ulDataTracks = 0;
[91]	797
[94]	798	CHAR cds1[4] = { 'C', 'D', '0', '1' };
	799	CHAR cds2[4];
[91]	800
	801	*pfAudio = FALSE;
	802
[94]	803	// check for proper driver signature
	804	if (!(arc = doshDevIOCtl(hfDrive,
	805	IOCTL_CDROMDISK,
	806	CDROMDISK_GETDRIVER,
	807	&cds1, sizeof(cds1),
	808	&cds2, sizeof(cds2))))
[91]	809	{
[94]	810	if (memcmp(&cds1, &cds2, 4))
	811	// this is not a CD-ROM then:
	812	arc = NO_ERROR;
	813	else
	814	{
[229]	815	#pragma pack(1) // V1.0.0 (2002-08-31) [umoeller]
[220]	816
[94]	817	struct {
	818	UCHAR ucFirstTrack,
	819	ucLastTrack;
	820	ULONG ulLeadOut;
	821	} cdat;
[91]	822
[220]	823	struct {
	824	ULONG ulTrackAddress;
	825	BYTE bFlags;
	826	} trackdata;
	827
	828	#pragma pack()
	829
[94]	830	// get track count
	831	if (!(arc = doshDevIOCtl(hfDrive,
	832	IOCTL_CDROMAUDIO,
	833	CDROMAUDIO_GETAUDIODISK,
	834	&cds1, sizeof(cds1),
	835	&cdat, sizeof(cdat))))
[91]	836	{
[94]	837	// still no error: build the audio TOC
	838	ULONG i;
	839	for (i = cdat.ucFirstTrack;
	840	i <= cdat.ucLastTrack;
	841	i++)
[91]	842	{
[94]	843	BYTE cdtp[5] =
	844	{ 'C', 'D', '0', '1', (UCHAR)i };
[91]	845
[94]	846	if (!(arc = doshDevIOCtl(hfDrive,
	847	IOCTL_CDROMAUDIO,
	848	CDROMAUDIO_GETAUDIOTRACK,
	849	&cdtp, sizeof(cdtp),
	850	&trackdata, sizeof(trackdata))))
	851	{
	852	if (trackdata.bFlags & 64)
	853	ulDataTracks++;
	854	else
[91]	855	{
[94]	856	ulAudioTracks++;
	857
	858	if (!fMixedModeCD)
[91]	859	{
[94]	860	// caller doesn't want mixed mode:
	861	// stop here
	862	ulDataTracks = 0;
	863	break;
[91]	864	}
	865	}
	866	}
[94]	867	}
[91]	868
[94]	869	// _Pmpf((" got %d audio, %d data tracks",
	870	// ulAudioTracks, ulDataTracks));
[91]	871
[94]	872	if (!ulDataTracks)
	873	*pfAudio = TRUE;
[91]	874	}
[94]	875	else
	876	{
	877	// not audio disk:
	878	// go on then
	879	// _Pmpf((" CDROMAUDIO_GETAUDIODISK returned %d", arc));
	880	arc = NO_ERROR;
	881	}
[91]	882	}
	883	}
[94]	884	else
	885	{
	886	// not CD-ROM: go on then
	887	// _Pmpf((" CDROMDISK_GETDRIVER returned %d", arc));
	888	arc = NO_ERROR;
	889	}
[91]	890
[167]	891	return arc;
[91]	892	}
	893
	894	/*
[220]	895	*@@ doshQueryCDStatus:
	896	* returns the status bits of a CD-ROM drive.
	897	* This calls the CDROMDISK_DEVICESTATUS
	898	* ioctl.
	899	*
	900	* If NO_ERROR is returned, *pflStatus has
	901	* received the following flags:
	902	*
	903	* -- CDFL_DOOROPEN (bit 0)
	904	*
	905	* -- CDFL_DOORLOCKED (bit 1)
	906	*
	907	* and many more (see dosh.h).
	908	*
	909	* Actually I wrote this function to have a way to
	910	* find out whether the drive door is already open.
	911	* But thanks to IBM's thoughtful design, this ioctl
	912	* is 99% useless for that purpose since it requires
	913	* a DASD disk handle to be passed in, which cannot
	914	* be obtained if there's no media in the drive.
	915	*
	916	* In other words, it is absolutely impossible to
	917	* ever get the CDFL_DOOROPEN flag, because if the
	918	* door is open, DosOpen already fails on the drive.
	919	* As a consequence, it is seems to be impossible
	920	* to find out if the door is open with OS/2.
	921	*
[229]	922	*@@added V1.0.0 (2002-08-31) [umoeller]
[220]	923	*/
	924
	925	APIRET doshQueryCDStatus(HFILE hfDrive, // in: DASD open
	926	PULONG pflStatus) // out: CD-ROM status bits
	927	{
	928	APIRET arc;
	929
	930	CHAR cds1[4] = { 'C', 'D', '0', '1' };
	931	ULONG fl;
	932
	933	*pflStatus = 0;
	934
	935	if (!(arc = doshDevIOCtl(hfDrive,
	936	IOCTL_CDROMDISK,
	937	CDROMDISK_DEVICESTATUS,
	938	&cds1, sizeof(cds1),
	939	&fl, sizeof(fl))))
	940	{
	941	*pflStatus = fl;
	942	}
	943
	944	return arc;
	945	}
	946
	947	/*
[8]	948	*@@ doshEnumDrives:
	949	* this function enumerates all valid drive letters on
	950	* the system by composing a string of drive letters
	951	* in the buffer pointed to by pszBuffer, which should
	952	* be 27 characters in size to hold information for
	953	* all drives. The buffer will be null-terminated.
	954	*
	955	* If (pcszFileSystem != NULL), only drives matching
	956	* the specified file system type (e.g. "HPFS") will
	957	* be enumerated. If (pcszFileSystem == NULL), all
	958	* drives will be enumerated.
	959	*
	960	* If (fSkipRemovables == TRUE), removeable drives will
	961	* be skipped. This applies to floppy, CD-ROM, and
	962	* virtual floppy drives. This will start the search
	963	* at drive letter C: so that drives A: and B: will
	964	* never be checked (to avoid the hardware bumps).
	965	*
	966	* Otherwise, the search starts at drive A:. Still,
	967	* removeable drives will only be added if valid media
	968	* is inserted.
	969	*
	970	*@@changed V0.9.4 (2000-07-03) [umoeller]: this stopped at the first invalid drive letter; fixed
	971	*@@changed V0.9.4 (2000-07-03) [umoeller]: added fSkipRemoveables
	972	*/
	973
	974	VOID doshEnumDrives(PSZ pszBuffer, // out: drive letters
[116]	975	PCSZ pcszFileSystem, // in: FS's to match or NULL
[8]	976	BOOL fSkipRemoveables) // in: if TRUE, only non-removeable disks will be returned
	977	{
[63]	978	CHAR szName[5] = "";
	979	ULONG ulLogicalDrive = 1, // start with drive A:
	980	ulFound = 0; // found drives count
	981	APIRET arc = NO_ERROR; // return code
[8]	982
	983	if (fSkipRemoveables)
	984	// start with drive C:
	985	ulLogicalDrive = 3;
	986
	987	// go thru the drives, start with C: (== 3), stop after Z: (== 26)
	988	while (ulLogicalDrive <= 26)
	989	{
	990	#pragma pack(1)
	991	struct
	992	{
	993	UCHAR dummy,drive;
	994	} parms;
	995	#pragma pack()
	996
[81]	997	// data packet
	998	UCHAR nonRemovable=0;
	999
[8]	1000	parms.drive=(UCHAR)(ulLogicalDrive-1);
[81]	1001	arc = doshDevIOCtl((HFILE)-1,
	1002	IOCTL_DISK,
	1003	DSK_BLOCKREMOVABLE,
	1004	&parms, sizeof(parms),
	1005	&nonRemovable, sizeof(nonRemovable));
[8]	1006
	1007	if ( // fixed disk and non-removeable
	1008	((arc == NO_ERROR) && (nonRemovable))
	1009	// or network drive:
	1010	\|\| (arc == ERROR_NOT_SUPPORTED)
	1011	)
	1012	{
	1013	ULONG ulOrdinal = 0; // ordinal of entry in name list
	1014	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
	1015	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
	1016	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
	1017
[108]	1018	szName[0] = ulLogicalDrive + 'A' - 1;
[8]	1019	szName[1] = ':';
	1020	szName[2] = '\0';
	1021
	1022	arc = DosQueryFSAttach(szName, // logical drive of attached FS
	1023	ulOrdinal, // ignored for FSAIL_QUERYNAME
	1024	FSAIL_QUERYNAME, // return data for a Drive or Device
	1025	pfsqBuffer, // returned data
	1026	&cbBuffer); // returned data length
	1027
	1028	if (arc == NO_ERROR)
	1029	{
	1030	// The data for the last three fields in the FSQBUFFER2
	1031	// structure are stored at the offset of fsqBuffer.szName.
	1032	// Each data field following fsqBuffer.szName begins
	1033	// immediately after the previous item.
	1034	CHAR* pszFSDName = (PSZ)&(pfsqBuffer->szName) + (pfsqBuffer->cbName) + 1;
	1035	if (pcszFileSystem == NULL)
	1036	{
	1037	// enum-all mode: always copy
	1038	pszBuffer[ulFound] = szName[0]; // drive letter
	1039	ulFound++;
	1040	}
	1041	else if (strcmp(pszFSDName, pcszFileSystem) == 0)
	1042	{
	1043	pszBuffer[ulFound] = szName[0]; // drive letter
	1044	ulFound++;
	1045	}
	1046	}
	1047	}
	1048
	1049	ulLogicalDrive++;
	1050	} // end while (G_acDriveLetters[ulLogicalDrive] <= 'Z')
	1051
	1052	pszBuffer[ulFound] = '\0';
	1053	}
	1054
	1055	/*
	1056	*@@ doshQueryBootDrive:
	1057	* returns the letter of the boot drive as a
	1058	* single (capital) character, which is useful for
	1059	* constructing file names using sprintf and such.
[133]	1060	*
	1061	*@@changed V0.9.16 (2002-01-13) [umoeller]: optimized
[8]	1062	*/
	1063
	1064	CHAR doshQueryBootDrive(VOID)
	1065	{
[133]	1066	// this can never change, so query this only once
	1067	// V0.9.16 (2002-01-13) [umoeller]
	1068	static CHAR cBootDrive = '\0';
	1069
	1070	if (!cBootDrive)
	1071	{
	1072	ULONG ulBootDrive;
	1073	DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
	1074	&ulBootDrive,
	1075	sizeof(ulBootDrive));
	1076	cBootDrive = (CHAR)ulBootDrive + 'A' - 1;
	1077	}
	1078
[220]	1079	return cBootDrive;
[8]	1080	}
	1081
	1082	/*
[133]	1083	*@@ doshQueryMedia:
	1084	* determines whether the given drive currently
	1085	* has media inserted.
	1086	*
	1087	* Call this only for non-fixed (removable) disks.
	1088	* Use doshIsFixedDisk to find out.
	1089	*
[220]	1090	* Returns:
	1091	*
	1092	* -- NO_ERROR: media is present.
	1093	*
	1094	* -- ERROR_AUDIO_CD_ROM (10000): audio CD-ROM is present.
	1095	*
	1096	* -- ERROR_NOT_READY (21) or other: drive has no media.
	1097	*
[133]	1098	*@@added V0.9.16 (2002-01-13) [umoeller]
	1099	*/
	1100
[220]	1101	APIRET doshQueryMedia(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
[135]	1102	BOOL fCDROM, // in: is drive CD-ROM?
[133]	1103	ULONG fl) // in: DRVFL_* flags
	1104	{
	1105	APIRET arc;
	1106
[220]	1107	HFILE hf;
[133]	1108
[229]	1109	// exported this code to doshOpenDrive V1.0.0 (2002-08-31) [umoeller]
[220]	1110	arc = doshOpenDrive(ulLogicalDrive,
	1111	&hf);
[133]	1112
	1113	// this still returns NO_ERROR for audio CDs in a
	1114	// CD-ROM drive...
	1115	// however, the WPS then attempts to read in the
	1116	// root directory for audio CDs, which produces
	1117	// a "sector not found" error box...
	1118
	1119	if ( (!arc)
	1120	&& (hf)
	1121	&& (fCDROM)
	1122	)
	1123	{
	1124	BOOL fAudio;
[220]	1125	if ( (!(arc = doshHasAudioCD(hf,
[133]	1126	((fl & DRVFL_MIXEDMODECD) != 0),
	1127	&fAudio)))
	1128	&& (fAudio)
	1129	)
	1130	arc = ERROR_AUDIO_CD_ROM; // special private error code (10000)
	1131	}
	1132
	1133	if (hf)
	1134	DosClose(hf);
	1135
[167]	1136	return arc;
[133]	1137	}
	1138
	1139	/*
[8]	1140	*@@ doshAssertDrive:
	1141	* this checks for whether the given drive
	1142	* is currently available without provoking
	1143	* those ugly white "Drive not ready" popups.
	1144	*
[81]	1145	* "fl" can specify additional flags for testing
	1146	* and can be any combination of:
	1147	*
[133]	1148	* -- DRVFL_MIXEDMODECD: whether to allow
[81]	1149	* mixed-mode CD-ROMs. See error codes below.
	1150	*
[8]	1151	* This returns (from my testing):
[81]	1152	*
[8]	1153	* -- NO_ERROR: drive is available.
[81]	1154	*
[8]	1155	* -- ERROR_INVALID_DRIVE (15): drive letter does not exist.
	1156	*
[81]	1157	* -- ERROR_NOT_READY (21): drive exists, but is not ready.
	1158	* This is produced by floppies and CD-ROM drives
	1159	* which do not have valid media inserted.
	1160	*
	1161	* -- ERROR_AUDIO_CD_ROM (10000): special error code returned
	1162	* only by this function if a CD-ROM drive has audio
	1163	* media inserted.
	1164	*
[133]	1165	* If DRVFL_MIXEDMODECD was specified, ERROR_AUDIO_CD_ROM
[81]	1166	* is returned _only_ if _no_ data tracks are
	1167	* present on a CD-ROM. Since OS/2 is not very
	1168	* good at handling mixed-mode CDs, this might not
	1169	* be desireable.
	1170	*
[133]	1171	* If DRVFL_MIXEDMODECD was not set, ERROR_AUDIO_CD_ROM
[81]	1172	* will be returned already if _one_ audio track is present.
	1173	*
[8]	1174	*@@changed V0.9.1 (99-12-13) [umoeller]: rewritten, prototype changed. Now using DosOpen on the drive instead of DosError.
	1175	*@@changed V0.9.1 (2000-01-08) [umoeller]: DosClose was called even if DosOpen failed, which messed up OS/2 error handling.
	1176	*@@changed V0.9.1 (2000-02-09) [umoeller]: this didn't work for network drives, including RAMFS; fixed.
	1177	*@@changed V0.9.3 (2000-03-28) [umoeller]: added check for network drives, which weren't working
	1178	*@@changed V0.9.4 (2000-08-03) [umoeller]: more network fixes
[50]	1179	*@@changed V0.9.9 (2001-03-19) [pr]: validate drive number
[63]	1180	*@@changed V0.9.11 (2001-04-23) [umoeller]: added an extra check for floppies
[81]	1181	*@@changed V0.9.13 (2001-06-14) [umoeller]: added "fl" parameter and lots of CD-ROM checks
[8]	1182	*/
	1183
[81]	1184	APIRET doshAssertDrive(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
[133]	1185	ULONG fl) // in: DRVFL_* flags
[8]	1186	{
[81]	1187	APIRET arc = NO_ERROR;
	1188	BOOL fFixed = FALSE,
	1189	fCDROM = FALSE;
[8]	1190
[50]	1191	if ((ulLogicalDrive < 1) \|\| (ulLogicalDrive > 26))
	1192	return(ERROR_PATH_NOT_FOUND);
	1193
[81]	1194	arc = doshIsFixedDisk(ulLogicalDrive,
	1195	&fFixed); // V0.9.13 (2001-06-14) [umoeller]
[8]	1196
[105]	1197	// _Pmpf((__FUNCTION__ ": doshIsFixedDisk returned %d for disk %d", arc, ulLogicalDrive));
	1198	// _Pmpf((" fFixed is %d", fFixed));
[8]	1199
[81]	1200	if (!arc)
	1201	if (!fFixed)
	1202	{
	1203	// removeable disk:
	1204	// check if it's a CD-ROM
	1205	BIOSPARAMETERBLOCK bpb;
	1206	arc = doshQueryDiskParams(ulLogicalDrive,
	1207	&bpb);
[105]	1208	// _Pmpf((" doshQueryDiskParams returned %d", arc));
[13]	1209
[81]	1210	if ( (!arc)
[135]	1211	&& (DRVTYPE_CDROM == doshQueryDriveType(ulLogicalDrive,
	1212	&bpb,
	1213	fFixed))
[81]	1214	)
	1215	{
[105]	1216	// _Pmpf((" --> is CD-ROM"));
[81]	1217	fCDROM = TRUE;
	1218	}
	1219	}
	1220
[94]	1221	if (!arc)
[133]	1222	arc = doshQueryMedia(ulLogicalDrive,
	1223	fCDROM,
	1224	fl);
[94]	1225
[8]	1226	switch (arc)
	1227	{
	1228	case ERROR_NETWORK_ACCESS_DENIED: // 65
	1229	// added V0.9.3 (2000-03-27) [umoeller];
	1230	// according to user reports, this is returned
	1231	// by all network drives, which apparently don't
	1232	// support DASD DosOpen
	1233	case ERROR_ACCESS_DENIED: // 5
	1234	// added V0.9.4 (2000-07-10) [umoeller]
	1235	// LAN drives still didn't work... apparently
	1236	// the above only works for NFS drives
	1237	case ERROR_PATH_NOT_FOUND: // 3
	1238	// added V0.9.4 (2000-08-03) [umoeller]:
	1239	// this is returned by some other network types...
	1240	// sigh...
	1241	case ERROR_NOT_SUPPORTED: // 50
	1242	// this is returned by file systems which don't
	1243	// support DASD DosOpen;
	1244	// use some other method then, this isn't likely
	1245	// to fail -- V0.9.1 (2000-02-09) [umoeller]
	1246
[63]	1247	// but don't do this for floppies
	1248	// V0.9.11 (2001-04-23) [umoeller]
	1249	if (ulLogicalDrive > 2)
	1250	{
	1251	FSALLOCATE fsa;
	1252	arc = DosQueryFSInfo(ulLogicalDrive,
	1253	FSIL_ALLOC,
	1254	&fsa,
	1255	sizeof(fsa));
[82]	1256	// _Pmpf((" re-checked, DosQueryFSInfo returned %d", arc));
[63]	1257	}
	1258	break;
[8]	1259	}
	1260
[167]	1261	return arc;
[8]	1262	}
	1263
	1264	/*
[133]	1265	*@@ doshGetDriveInfo:
	1266	* fills the given XDISKINFO buffer with
	1267	* information about the given logical drive.
	1268	*
	1269	* This function will not provoke "Drive not
[135]	1270	* ready" popups, hopefully.
[133]	1271	*
	1272	* fl can be any combination of the following:
	1273	*
	1274	* -- DRVFL_MIXEDMODECD: see doshAssertDrive.
	1275	*
	1276	* -- DRVFL_TOUCHFLOPPIES: drive A: and B: should
	1277	* be touched for media checks (click, click);
	1278	* otherwise they will be left alone and
	1279	* default values will be returned.
	1280	*
[135]	1281	* -- DRVFL_CHECKEAS: drive should always be
	1282	* checked for EA support. If this is set,
	1283	* we will call DosFSCtl for the non-well-known
	1284	* file systems so we will always have a
	1285	* value for the DFL_SUPPORTS_EAS flags.
	1286	* The EA support returned by DosFSCtl
	1287	* might not be correct for remote file
	1288	* systems since not all of them support
	1289	* that query.
[133]	1290	*
[220]	1291	* If not set, we set DFL_SUPPORTS_EAS only
	1292	* for file systems such as HPFS and JFS
	1293	* that are known to support EAs.
	1294	*
	1295	* -- DRVFL_CHECKLONGNAMES: drive should be
	1296	* tested for longname support. If this is
[153]	1297	* set, we will try a DosOpen("\\long.name.file")
	1298	* on the drive to see if it supports long
	1299	* filenames (unless it's a "well-known"
	1300	* file-system and we know it does). If enabled,
	1301	* the DFL_SUPPORTS_LONGNAMES flag is reliable.
	1302	* Note that this does not check for what special
	1303	* characters are supported in file names.
[133]	1304	*
[135]	1305	* This should return only one of the following:
	1306	*
[133]	1307	* -- NO_ERROR: disk info was filled, but not
	1308	* necessarily all info was available (e.g.
	1309	* if no media was present in CD-ROM drive).
[135]	1310	* See remarks below.
[133]	1311	*
[135]	1312	* -- ERROR_INVALID_DRIVE 15): ulLogicalDrive
	1313	* is not used at all (invalid drive letter)
	1314	*
	1315	* -- ERROR_BAD_UNIT (20): if drive was renamed for
	1316	* some reason (according to user reports
	1317	*
	1318	* -- ERROR_NOT_READY (21): for ZIP disks where
	1319	* no media is inserted, depending on the
	1320	* driver apparently... normally ZIP drive
	1321	* letters should disappear when no media
	1322	* is present
	1323	*
	1324	* -- ERROR_DRIVE_LOCKED (108)
	1325	*
	1326	* So in order to check whether a drive is present
	1327	* and available, use this function as follows:
	1328	*
	1329	* 1) Call this function and check whether it
	1330	* returns NO_ERROR for the given drive.
	1331	* This will rule out invalid drive letters
[153]	1332	* and drives that are presently locked by
	1333	* CHKDSK or something.
[135]	1334	*
	1335	* 2) If so, check whether XDISKINFO.flDevice
	1336	* has the DFL_MEDIA_PRESENT flag set.
	1337	* This will rule out removeable drives without
	1338	* media and unformatted hard disks.
	1339	*
	1340	* 3) If so, you can test the other fields if
	1341	* you need more information. For example,
	1342	* it would not be a good idea to create
	1343	* a new file if the bType field is
	1344	* DRVTYPE_CDROM.
	1345	*
	1346	* If you want to exclude removeable disks,
	1347	* instead of checking bType, you should
	1348	* rather check flDevice for the DFL_FIXED
	1349	* flag, which will be set for ZIP drives also.
	1350	*
	1351	* Remarks for special drive types:
	1352	*
	1353	* -- Hard disks always have bType == DRVTYPE_HARDDISK.
	1354	* For them, we always check the file system.
	1355	* If this is reported as "UNKNOWN", this means
	1356	* that the drive is unformatted or formatted
	1357	* with a file system that OS/2 does not understand
	1358	* (e.g. NTFS). Only in that case, flDevice
	1359	* has the DFL_MEDIA_PRESENT bit clear.
	1360	*
	1361	* DFL_FIXED is always set.
	1362	*
	1363	* -- Remote (LAN) drives always have bType == DRVTYPE_LAN.
	1364	* flDevice will always have the DFL_REMOTE and
	1365	* DFL_MEDIA_PRESENT bits set.
	1366	*
	1367	* -- ZIP disks will have bType == DRVTYPE_PARTITIONABLEREMOVEABLE.
	1368	* For them, flDevice will have both the
	1369	* and DFL_PARTITIONABLEREMOVEABLE and DFL_FIXED
	1370	* bits set.
	1371	*
	1372	* ZIP disks are a bit special because they are
	1373	* dynamically mounted and unmounted when media
	1374	* is inserted and removed. In other words, if
	1375	* no media is present, the drive letter becomes
	1376	* invalid.
	1377	*
	1378	* -- CD-ROM and DVD drives and CD writers will always
	1379	* be reported as DRVTYPE_CDROM. The DFL_FIXED bit
	1380	* will be clear always. For them, always check the
	1381	* DFL_MEDIA_PRESENT present bit to avoid "Drive not
	1382	* ready" popups.
	1383	*
	1384	* As a special goody, we can also determine if the
	1385	* drive currently has audio media inserted (which
	1386	* would provoke errors also), by setting the
	1387	* DFL_AUDIO_CD bit.
	1388	*
[133]	1389	*@@added V0.9.16 (2002-01-13) [umoeller]
[161]	1390	*@@changed V0.9.19 (2002-04-25) [umoeller]: added CDWFS (RSJ CD-Writer)
[133]	1391	*/
	1392
	1393	APIRET doshGetDriveInfo(ULONG ulLogicalDrive,
	1394	ULONG fl, // in: DRVFL_* flags
	1395	PXDISKINFO pdi)
	1396	{
	1397	APIRET arc = NO_ERROR;
	1398
	1399	HFILE hf;
	1400	ULONG dummy;
[135]	1401	BOOL fCheck = TRUE,
	1402	fCheckFS = FALSE,
	1403	fCheckLongnames = FALSE,
	1404	fCheckEAs = FALSE;
[133]	1405
	1406	memset(pdi, 0, sizeof(XDISKINFO));
	1407
	1408	pdi->cDriveLetter = 'A' + ulLogicalDrive - 1;
	1409	pdi->cLogicalDrive = ulLogicalDrive;
	1410
	1411	pdi->bType = DRVTYPE_UNKNOWN;
	1412	pdi->fPresent = TRUE; // for now
	1413
	1414	if ( (ulLogicalDrive == 1)
	1415	\|\| (ulLogicalDrive == 2)
	1416	)
	1417	{
	1418	// drive A: and B: are special cases,
	1419	// we don't even want to touch them (click, click)
	1420	pdi->bType = DRVTYPE_FLOPPY;
	1421
	1422	if (0 == (fl & DRVFL_TOUCHFLOPPIES))
	1423	{
	1424	fCheck = FALSE;
	1425	// these support EAs too
	1426	pdi->flDevice = DFL_MEDIA_PRESENT \| DFL_SUPPORTS_EAS;
	1427	strcpy(pdi->szFileSystem, "FAT");
[135]	1428	pdi->lFileSystem = FSYS_FAT;
[133]	1429	}
	1430	}
	1431
	1432	if (fCheck)
	1433	{
	1434	// any other drive:
	1435	// check if it's removeable first
	1436	BOOL fFixed = FALSE;
	1437	arc = doshIsFixedDisk(ulLogicalDrive,
	1438	&fFixed);
	1439
[135]	1440	switch (arc)
[133]	1441	{
[135]	1442	case ERROR_INVALID_DRIVE:
	1443	// drive letter doesn't exist at all:
	1444	pdi->fPresent = FALSE;
	1445	// return this APIRET
	1446	break;
[133]	1447
[135]	1448	case ERROR_NOT_SUPPORTED: // 50 for network drives
	1449	// we get this for remote drives added
	1450	// via "net use", so set these flags
	1451	pdi->bType = DRVTYPE_LAN;
	1452	pdi->lFileSystem = FSYS_REMOTE;
	1453	pdi->flDevice \|= DFL_REMOTE \| DFL_MEDIA_PRESENT;
	1454	// but still check what file-system we
	1455	// have and whether longnames are supported
	1456	fCheckFS = TRUE;
	1457	fCheckLongnames = TRUE;
	1458	fCheckEAs = TRUE;
	1459	break;
[133]	1460
[135]	1461	case NO_ERROR:
[133]	1462	{
[135]	1463	if (fFixed)
[133]	1464	{
[135]	1465	// fixed drive:
	1466	pdi->flDevice \|= DFL_FIXED \| DFL_MEDIA_PRESENT;
	1467
	1468	fCheckFS = TRUE;
	1469	fCheckLongnames = TRUE;
	1470	fCheckEAs = TRUE;
	1471	}
	1472
	1473	if (!(arc = doshQueryDiskParams(ulLogicalDrive,
	1474	&pdi->bpb)))
	1475	{
	1476	BYTE bTemp = doshQueryDriveType(ulLogicalDrive,
	1477	&pdi->bpb,
	1478	fFixed);
	1479	if (bTemp != DRVTYPE_UNKNOWN)
[133]	1480	{
[135]	1481	// recognized: store it then
[133]	1482	pdi->bType = bTemp;
	1483
[220]	1484	if (bTemp == DRVTYPE_PRT)
[133]	1485	pdi->flDevice \|= DFL_FIXED
	1486	\| DFL_PARTITIONABLEREMOVEABLE;
	1487	}
	1488
[135]	1489	if (!fFixed)
[133]	1490	{
[135]	1491	// removeable:
	1492
	1493	// before checking the drive, try if we have media
	1494	if (!(arc = doshQueryMedia(ulLogicalDrive,
	1495	(pdi->bType == DRVTYPE_CDROM),
	1496	fl)))
	1497	{
	1498	pdi->flDevice \|= DFL_MEDIA_PRESENT;
	1499	fCheckFS = TRUE;
	1500	fCheckLongnames = TRUE;
	1501	// but never EAs
	1502	}
	1503	else if (arc == ERROR_AUDIO_CD_ROM)
	1504	{
	1505	pdi->flDevice \|= DFL_AUDIO_CD;
	1506	// do not check longnames and file-system
	1507	}
	1508	else
	1509	pdi->arcQueryMedia = arc;
	1510
	1511	arc = NO_ERROR;
[133]	1512	}
	1513	}
	1514	else
[135]	1515	pdi->arcQueryDiskParams = arc;
[133]	1516	}
[135]	1517	break;
	1518
	1519	default:
	1520	pdi->arcIsFixedDisk = arc;
	1521	// and return this
	1522	break;
	1523
	1524	} // end swich arc = doshIsFixedDisk(ulLogicalDrive, &fFixed);
	1525	}
	1526
	1527	if (fCheckFS)
	1528	{
	1529	// TRUE only for local fixed disks or
	1530	// remote drives or if media was present above
	1531	if (!(arc = doshQueryDiskFSType(ulLogicalDrive,
	1532	pdi->szFileSystem,
	1533	sizeof(pdi->szFileSystem))))
	1534	{
	1535	if (!stricmp(pdi->szFileSystem, "UNKNOWN"))
[133]	1536	{
[135]	1537	// this is returned by the stupid DosQueryFSAttach
	1538	// if the file system is not recognized by OS/2,
	1539	// or if the drive is unformatted
	1540	pdi->lFileSystem = FSYS_UNKNOWN;
	1541	pdi->flDevice &= ~DFL_MEDIA_PRESENT;
	1542	fCheckLongnames = FALSE;
	1543	fCheckEAs = FALSE;
	1544	// should we return ERROR_NOT_DOS_DISK (26)
	1545	// in this case?
	1546	}
	1547	else if (!stricmp(pdi->szFileSystem, "FAT"))
	1548	{
	1549	pdi->lFileSystem = FSYS_FAT;
	1550	pdi->flDevice \|= DFL_SUPPORTS_EAS;
	1551	fCheckLongnames = FALSE;
	1552	fCheckEAs = FALSE;
	1553	}
	1554	else if ( (!stricmp(pdi->szFileSystem, "HPFS"))
	1555	\|\| (!stricmp(pdi->szFileSystem, "JFS"))
	1556	)
	1557	{
	1558	pdi->lFileSystem = FSYS_HPFS_JFS;
	1559	pdi->flDevice \|= DFL_SUPPORTS_EAS \| DFL_SUPPORTS_LONGNAMES;
	1560	fCheckLongnames = FALSE;
	1561	fCheckEAs = FALSE;
	1562	}
	1563	else if (!stricmp(pdi->szFileSystem, "CDFS"))
	1564	pdi->lFileSystem = FSYS_CDFS;
	1565	else if ( (!stricmp(pdi->szFileSystem, "FAT32"))
	1566	\|\| (!stricmp(pdi->szFileSystem, "ext2"))
	1567	)
	1568	{
	1569	pdi->lFileSystem = FSYS_FAT32_EXT2;
[133]	1570	fCheckLongnames = TRUE;
[135]	1571	fCheckEAs = TRUE;
[133]	1572	}
[135]	1573	else if (!stricmp(pdi->szFileSystem, "RAMFS"))
[133]	1574	{
[135]	1575	pdi->lFileSystem = FSYS_RAMFS;
	1576	pdi->flDevice \|= DFL_SUPPORTS_EAS \| DFL_SUPPORTS_LONGNAMES;
	1577	fCheckLongnames = FALSE;
	1578	fCheckEAs = FALSE;
[133]	1579	}
[135]	1580	else if (!stricmp(pdi->szFileSystem, "TVFS"))
[133]	1581	{
[135]	1582	pdi->lFileSystem = FSYS_TVFS;
	1583	fCheckLongnames = TRUE;
	1584	fCheckEAs = TRUE;
	1585	}
[161]	1586	else if (!stricmp(pdi->szFileSystem, "CDWFS"))
	1587	// V0.9.19 (2002-04-25) [umoeller]
	1588	{
	1589	pdi->lFileSystem = FSYS_CDWFS;
	1590	pdi->flDevice \|= DFL_SUPPORTS_LONGNAMES;
	1591	fCheckLongnames = FALSE;
	1592	fCheckEAs = FALSE;
	1593	}
[135]	1594	}
	1595	else
	1596	// store negative error code
	1597	pdi->lFileSystem = -(LONG)arc;
	1598	}
[133]	1599
[135]	1600	if ( (!arc)
	1601	&& (fCheckLongnames)
	1602	&& (fl & DRVFL_CHECKLONGNAMES)
	1603	)
	1604	{
[240]	1605	CHAR szTemp[] = "?:\\long.name.file";
[135]	1606	szTemp[0] = ulLogicalDrive + 'A' - 1;
	1607	if (!(arc = DosOpen(szTemp,
	1608	&hf,
	1609	&dummy,
	1610	0,
	1611	0,
	1612	FILE_READONLY,
	1613	OPEN_SHARE_DENYNONE \| OPEN_FLAGS_NOINHERIT,
	1614	0)))
	1615	{
	1616	DosClose(hf);
	1617	}
[133]	1618
[135]	1619	switch (arc)
	1620	{
	1621	case NO_ERROR:
	1622	case ERROR_OPEN_FAILED:
	1623	case ERROR_FILE_NOT_FOUND: // returned by TVFS
	1624	pdi->flDevice \|= DFL_SUPPORTS_LONGNAMES;
	1625	break;
[133]	1626
[135]	1627	// if longnames are not supported,
	1628	// we get ERROR_INVALID_NAME
	1629	default:
	1630	pdi->arcOpenLongnames = arc;
	1631	break;
	1632
	1633	// default:
	1634	// printf(" drive %d returned %d\n", ulLogicalDrive, arc);
[133]	1635	}
[135]	1636
	1637	arc = NO_ERROR;
[133]	1638	}
	1639
[135]	1640	if ( (!arc)
	1641	&& (fCheckEAs)
	1642	&& (fl & DRVFL_CHECKEAS)
	1643	)
	1644	{
	1645	EASIZEBUF easb = {0};
	1646	ULONG cbData = sizeof(easb),
	1647	cbParams = 0;
	1648	CHAR szDrive[] = "?:\\";
	1649	szDrive[0] = pdi->cDriveLetter;
	1650	if (!(arc = DosFSCtl(&easb,
	1651	cbData,
	1652	&cbData,
	1653	NULL, // params,
	1654	cbParams,
	1655	&cbParams,
	1656	FSCTL_MAX_EASIZE,
	1657	szDrive,
	1658	-1, // HFILE
	1659	FSCTL_PATHNAME)))
	1660	if (easb.cbMaxEASize != 0)
	1661	// the other field (cbMaxEAListSize) is 0 always, I think
	1662	pdi->flDevice \|= DFL_SUPPORTS_EAS;
	1663	}
	1664
[133]	1665	if (doshQueryBootDrive() == pdi->cDriveLetter)
	1666	pdi->flDevice \|= DFL_BOOTDRIVE;
	1667
[167]	1668	return arc;
[133]	1669	}
	1670
	1671	/*
[14]	1672	*@@ doshSetLogicalMap:
[161]	1673	* sets the mapping of logical floppy drives onto a single
	1674	* physical floppy drive.
	1675	* This means selecting either drive A: or drive B: to refer
	1676	* to the physical drive.
[14]	1677	*
[161]	1678	* Paul explained this to me as follows:
	1679	*
	1680	* "It is really very simple - in a single physical floppy
	1681	* drive system, you still have 2 logical floppy drives
	1682	* A: and B:. This was primarily to support disk copying
	1683	* e.g. diskcopy a: b: on a single floppy system without
	1684	* having to rewrite applications. Whenever the application
	1685	* accessed the other logical drive, the user would get a
	1686	* prompt from the OS to swap disks.
	1687	*
	1688	* "These calls allow applications to bypass the prompt by
	1689	* doing the mapping themselves. They just get/set which
	1690	* logical drive is currently mapped to the physical drive.
	1691	* This concept existed in DOS as well although the specifics
	1692	* of how it was done escape me now.... actually I just
	1693	* looked it up - the byte at 0:504h in low memory on
	1694	* DOS controlled this (it doesn't work in VDMs)."
	1695	*
[14]	1696	*@@added V0.9.6 (2000-11-24) [pr]
	1697	*/
	1698
	1699	APIRET doshSetLogicalMap(ULONG ulLogicalDrive)
	1700	{
	1701	CHAR name[3] = "?:";
	1702	ULONG fd = 0,
[91]	1703	action = 0;
	1704	// paramsize = 0;
	1705	// datasize = 0;
[63]	1706	APIRET rc = NO_ERROR;
	1707	USHORT data,
	1708	param;
[14]	1709
	1710	name[0] = doshQueryBootDrive();
	1711	rc = DosOpen(name,
	1712	&fd,
	1713	&action,
	1714	0,
	1715	0,
	1716	OPEN_ACTION_FAIL_IF_NEW
	1717	\| OPEN_ACTION_OPEN_IF_EXISTS,
	1718	OPEN_FLAGS_DASD
	1719	\| OPEN_FLAGS_FAIL_ON_ERROR
	1720	\| OPEN_FLAGS_NOINHERIT
	1721	\| OPEN_ACCESS_READONLY
	1722	\| OPEN_SHARE_DENYNONE,
	1723	0);
[60]	1724
[14]	1725	if (rc == NO_ERROR)
	1726	{
	1727	param = 0;
	1728	data = (USHORT)ulLogicalDrive;
[91]	1729	// paramsize = sizeof(param);
	1730	// datasize = sizeof(data);
[81]	1731	rc = doshDevIOCtl(fd,
	1732	IOCTL_DISK, DSK_SETLOGICALMAP,
	1733	&param, sizeof(param),
	1734	&data, sizeof(data));
[14]	1735	DosClose(fd);
	1736	}
	1737
	1738	return(rc);
	1739	}
	1740
	1741	/*
[60]	1742	*@@ doshQueryDiskSize:
	1743	* returns the size of the specified disk in bytes.
	1744	*
	1745	* Note: This returns a "double" value, because a ULONG
	1746	* can only hold values of some 4 billion, which would
	1747	* lead to funny results for drives > 4 GB.
	1748	*
	1749	*@@added V0.9.11 (2001-04-18) [umoeller]
	1750	*/
	1751
	1752	APIRET doshQueryDiskSize(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	1753	double *pdSize)
	1754	{
	1755	APIRET arc = NO_ERROR;
	1756	FSALLOCATE fsa;
[91]	1757	// double dbl = -1;
[60]	1758
	1759	if (!(arc = DosQueryFSInfo(ulLogicalDrive, FSIL_ALLOC, &fsa, sizeof(fsa))))
	1760	pdSize = ((double)fsa.cSectorUnit fsa.cbSector * fsa.cUnit);
	1761
[167]	1762	return arc;
[60]	1763	}
	1764
	1765	/*
[8]	1766	*@@ doshQueryDiskFree:
[60]	1767	* returns the number of bytes remaining on the disk
	1768	* specified by the given logical drive.
[8]	1769	*
[60]	1770	* Note: This returns a "double" value, because a ULONG
	1771	* can only hold values of some 4 billion, which would
	1772	* lead to funny results for drives > 4 GB.
[8]	1773	*
	1774	*@@changed V0.9.0 [umoeller]: fixed another > 4 GB bug (thanks to Rdiger Ihle)
[14]	1775	*@@changed V0.9.7 (2000-12-01) [umoeller]: changed prototype
[8]	1776	*/
	1777
[14]	1778	APIRET doshQueryDiskFree(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	1779	double *pdFree)
[8]	1780	{
[14]	1781	APIRET arc = NO_ERROR;
[8]	1782	FSALLOCATE fsa;
[91]	1783	// double dbl = -1;
[8]	1784
[60]	1785	if (!(arc = DosQueryFSInfo(ulLogicalDrive, FSIL_ALLOC, &fsa, sizeof(fsa))))
[14]	1786	pdFree = ((double)fsa.cSectorUnit fsa.cbSector * fsa.cUnitAvail);
[8]	1787	// ^ fixed V0.9.0
	1788
[167]	1789	return arc;
[8]	1790	}
	1791
	1792	/*
	1793	*@@ doshQueryDiskFSType:
	1794	* copies the file-system type of the given disk object
	1795	* (HPFS, FAT, CDFS etc.) to pszBuf.
	1796	* Returns the DOS error code.
	1797	*
	1798	*@@changed V0.9.1 (99-12-12) [umoeller]: added cbBuf to prototype
[91]	1799	*@@changed V0.9.14 (2001-08-01) [umoeller]: fixed, this never respected cbBuf
[108]	1800	*@@changed V0.9.16 (2001-10-02) [umoeller]: added check for valid logical disk no
[413]	1801	*@@changed V1.0.10 (2012-06-14) [pr]: fix buffer overwrite @@fixes 1206
[8]	1802	*/
	1803
	1804	APIRET doshQueryDiskFSType(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	1805	PSZ pszBuf, // out: buffer for FS type
	1806	ULONG cbBuf) // in: size of that buffer
	1807	{
	1808	APIRET arc = NO_ERROR;
	1809	CHAR szName[5];
	1810
	1811	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
	1812	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
	1813	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
	1814
	1815	// compose "D:"-type string from logical drive letter
[108]	1816	if (ulLogicalDrive > 0 && ulLogicalDrive < 27)
	1817	{
	1818	szName[0] = ulLogicalDrive + 'A' - 1;
	1819	szName[1] = ':';
	1820	szName[2] = '\0';
[8]	1821
[108]	1822	arc = DosQueryFSAttach(szName, // logical drive of attached FS ("D:"-style)
	1823	0, // ulOrdinal, ignored for FSAIL_QUERYNAME
	1824	FSAIL_QUERYNAME, // return name for a drive or device
	1825	pfsqBuffer, // buffer for returned data
	1826	&cbBuffer); // sizeof(*pfsqBuffer)
[8]	1827
[108]	1828	if (arc == NO_ERROR)
[8]	1829	{
[413]	1830	if (pszBuf && cbBuf)
[108]	1831	{
	1832	// The data for the last three fields in the FSQBUFFER2
	1833	// structure are stored at the offset of fsqBuffer.szName.
	1834	// Each data field following fsqBuffer.szName begins
	1835	// immediately after the previous item.
	1836	strncpy(pszBuf,
	1837	(CHAR*)(&pfsqBuffer->szName) + pfsqBuffer->cbName + 1,
	1838	cbBuf); // V0.9.14 (2001-08-01) [umoeller]
[413]	1839	*(pszBuf + cbBuf - 1) = '\0';
[108]	1840	}
[8]	1841	}
	1842	}
[108]	1843	else
	1844	arc = ERROR_INVALID_PARAMETER; // V0.9.16 (2001-10-02) [umoeller]
[8]	1845
[167]	1846	return arc;
[8]	1847	}
	1848
	1849	/*
	1850	*@@ doshQueryDiskLabel:
	1851	* this returns the label of a disk into
	1852	* *pszVolumeLabel, which must be 12 bytes
	1853	* in size.
	1854	*
	1855	* This function was added because the Toolkit
	1856	* information for DosQueryFSInfo is only partly
	1857	* correct. On OS/2 2.x, that function does not
	1858	* take an FSINFO structure as input, but a VOLUMELABEL.
	1859	* On Warp, this does take an FSINFO.
	1860	*
	1861	* DosSetFSInfo is even worse. See doshSetDiskLabel.
	1862	*
	1863	* See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
	1864	* for details.
	1865	*
	1866	*@@added V0.9.0 [umoeller]
[63]	1867	*@@changed V0.9.11 (2001-04-22) [umoeller]: this copied even with errors, fixed
[8]	1868	*/
	1869
	1870	APIRET doshQueryDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	1871	PSZ pszVolumeLabel) // out: volume label (must be 12 chars in size)
	1872	{
	1873	APIRET arc;
	1874
	1875	#ifdef __OS2V2X__
	1876	VOLUMELABEL FSInfoBuf;
	1877	#else
	1878	FSINFO FSInfoBuf;
	1879	#endif
	1880
	1881	arc = DosQueryFSInfo(ulLogicalDrive,
	1882	FSIL_VOLSER,
	1883	&FSInfoBuf,
	1884	sizeof(FSInfoBuf)); // depends
	1885
[63]	1886	if (!arc) // V0.9.11 (2001-04-22) [umoeller]
	1887	{
	1888	#ifdef __OS2V2X__
	1889	strcpy(pszVolumeLabel, FSInfoBuf.szVolLabel);
	1890	#else
	1891	strcpy(pszVolumeLabel, FSInfoBuf.vol.szVolLabel);
	1892	#endif
	1893	}
[8]	1894
[167]	1895	return arc;
[8]	1896	}
	1897
	1898	/*
	1899	*@@ doshSetDiskLabel:
	1900	* this sets the label of a disk.
	1901	*
	1902	* This function was added because the Toolkit
	1903	* information for DosSetFSInfo is flat out wrong.
	1904	* That function does not take an FSINFO structure
	1905	* as input, but a VOLUMELABEL. As a result, using
	1906	* that function with the Toolkit's calling specs
	1907	* results in ERROR_LABEL_TOO_LONG always.
	1908	*
	1909	* See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
	1910	* for details.
	1911	*
	1912	*@@added V0.9.0 [umoeller]
	1913	*/
	1914
	1915	APIRET doshSetDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
	1916	PSZ pszNewLabel)
	1917	{
	1918	VOLUMELABEL FSInfoBuf;
	1919
	1920	// check length; 11 chars plus null byte allowed
	1921	FSInfoBuf.cch = (BYTE)strlen(pszNewLabel);
	1922	if (FSInfoBuf.cch < sizeof(FSInfoBuf.szVolLabel))
	1923	{
	1924	strcpy(FSInfoBuf.szVolLabel, pszNewLabel);
	1925
[238]	1926	return DosSetFSInfo(ulLogicalDrive,
	1927	FSIL_VOLSER,
	1928	&FSInfoBuf,
	1929	sizeof(FSInfoBuf));
[8]	1930	}
[238]	1931
	1932	return ERROR_LABEL_TOO_LONG;
[8]	1933	}
	1934
	1935	/*
[116]	1936	*@@category: Helpers\Control program helpers\File name parsing
[8]	1937	*/
	1938
	1939	/* ******************************************************************
[14]	1940	*
[116]	1941	* File name parsing
[14]	1942	*
[8]	1943	********************************************************************/
	1944
	1945	/*
[116]	1946	*@@ doshGetDriveSpec:
	1947	* returns the drive specification in pcszFullFile,
	1948	* if any is present. This is useful for UNC support.
	1949	*
	1950	* This returns:
	1951	*
	1952	* -- NO_ERROR: drive spec was given, and the output
	1953	* fields have been set.
	1954	*
	1955	* -- ERROR_INVALID_NAME: incorrect UNC syntax.
	1956	*
	1957	* -- ERROR_INVALID_DRIVE: second char is ':', but
	1958	* drive letter is not in the range [A-Z].
	1959	*
	1960	* -- ERROR_INVALID_PARAMETER: no drive spec given
	1961	* at all; apparently pcszFullFile is not fully
	1962	* qualified in the first place, or it is NULL,
	1963	* or its length is <= 2.
	1964	*
	1965	*@@added V0.9.16 (2001-10-25) [umoeller]
	1966	*/
	1967
	1968	APIRET doshGetDriveSpec(PCSZ pcszFullFile, // in: fully q'fied file spec
	1969	PSZ pszDrive, // out: drive spec ("C:" or "\\SERVER\RESOURCE"; ptr can be NULL)
	1970	PULONG pulDriveLen, // out: length of drive spec (2 if local drive; ptr can be NULL)
	1971	PBOOL pfIsUNC) // out: set to TRUE if UNC name, FALSE otherwise (ptr can be NULL)
	1972	{
	1973	APIRET arc = NO_ERROR;
	1974	ULONG ulFileSpecLength;
	1975
	1976	if ( (pcszFullFile)
	1977	&& (ulFileSpecLength = strlen(pcszFullFile))
	1978	&& (ulFileSpecLength >= 2)
	1979	)
	1980	{
	1981	// upper-case the drive letter
	1982	if (pcszFullFile[1] == ':')
	1983	{
	1984	CHAR cDrive = toupper(*pcszFullFile);
	1985	// local drive specified:
	1986	if ( (cDrive >= 'A')
	1987	&& (cDrive <= 'Z')
	1988	)
	1989	{
	1990	if (pszDrive)
	1991	{
	1992	pszDrive[0] = cDrive;
	1993	pszDrive[1] = ':';
	1994	pszDrive[2] = '\0';
	1995	}
	1996
	1997	if (pulDriveLen)
	1998	*pulDriveLen = 2;
	1999	if (pfIsUNC)
	2000	*pfIsUNC = FALSE;
	2001	}
	2002	else
	2003	// this is not a valid drive:
	2004	arc = ERROR_INVALID_DRIVE;
	2005	}
	2006	else if ( (pcszFullFile[0] == '\\')
	2007	&& (pcszFullFile[1] == '\\')
	2008	)
	2009	{
	2010	// UNC drive specified:
	2011	// this better be a full \\SERVER\RESOURCE string
	2012	PCSZ pResource;
	2013	if (pResource = strchr(pcszFullFile + 3, '\\'))
	2014	{
	2015	// we got at least \\SERVER\:
	2016	ULONG ulLength;
	2017	PCSZ p;
	2018
	2019	// check if more stuff is coming
	2020	if (p = strchr(pResource + 1, '\\'))
	2021	{
	2022	// yes: copy server and resource excluding that backslash
	2023	if (p == pResource + 1)
	2024	// "\\SERVER\\" is invalid
	2025	arc = ERROR_INVALID_NAME;
	2026	else
	2027	// we got "\\SERVER\something\":
	2028	// drop the last backslash
	2029	ulLength = p - pcszFullFile;
	2030	}
	2031	else
	2032	// "\\SERVER\something" only:
	2033	ulLength = ulFileSpecLength;
	2034
	2035	if (!arc)
	2036	{
	2037	if (pszDrive)
	2038	{
	2039	memcpy(pszDrive,
	2040	pcszFullFile,
	2041	ulLength);
	2042	pszDrive[ulLength] = '\0';
	2043	}
	2044
	2045	if (pulDriveLen)
	2046	*pulDriveLen = ulLength;
	2047	if (pfIsUNC)
	2048	*pfIsUNC = TRUE;
	2049	}
	2050	}
	2051	else
	2052	// invalid UNC name:
	2053	arc = ERROR_INVALID_NAME;
	2054	}
	2055	else
	2056	// neither local, nor UNC:
	2057	arc = ERROR_INVALID_PARAMETER;
	2058	}
	2059	else
	2060	arc = ERROR_INVALID_PARAMETER;
	2061
[167]	2062	return arc;
[116]	2063	}
	2064
	2065	/*
[8]	2066	*@@ doshGetExtension:
	2067	* finds the file name extension of pszFilename,
	2068	* which can be a file name only or a fully
	2069	* qualified filename.
	2070	*
	2071	* This returns a pointer into pszFilename to
	2072	* the character after the last dot.
	2073	*
	2074	* Returns NULL if not found (e.g. if the filename
	2075	* has no dot in it).
	2076	*
[123]	2077	* In the pathological case of a dot in the path
[159]	2078	* but not in the filename itself (e.g.
	2079	* "C:\files.new\readme"), this correctly returns
	2080	* NULL.
[123]	2081	*
[8]	2082	*@@added V0.9.6 (2000-10-16) [umoeller]
[15]	2083	*@@changed V0.9.7 (2000-12-10) [umoeller]: fixed "F:filename.ext" case
[8]	2084	*/
	2085
[116]	2086	PSZ doshGetExtension(PCSZ pcszFilename)
[8]	2087	{
[15]	2088	PSZ pReturn = NULL;
[8]	2089
	2090	if (pcszFilename)
	2091	{
	2092	// find filename
[123]	2093	PCSZ p2,
[116]	2094	pStartOfName = NULL,
	2095	pExtension = NULL;
[8]	2096
[123]	2097	if (p2 = strrchr(pcszFilename + 2, '\\'))
	2098	// works on "C:\blah" or "\\unc\blah"
[15]	2099	pStartOfName = p2 + 1;
	2100	else
	2101	{
	2102	// no backslash found:
	2103	// maybe only a drive letter was specified:
[116]	2104	if (pcszFilename[1] == ':')
[15]	2105	// yes:
	2106	pStartOfName = pcszFilename + 2;
	2107	else
	2108	// then this is not qualified at all...
	2109	// use start of filename
	2110	pStartOfName = (PSZ)pcszFilename;
	2111	}
[8]	2112
	2113	// find last dot in filename
[123]	2114	if (pExtension = strrchr(pStartOfName, '.'))
[15]	2115	pReturn = (PSZ)pExtension + 1;
[8]	2116	}
	2117
[238]	2118	return pReturn;
[8]	2119	}
	2120
	2121	/*
[116]	2122	*@@category: Helpers\Control program helpers\File management
	2123	*/
	2124
	2125	/* ******************************************************************
	2126	*
	2127	* File helpers
	2128	*
	2129	********************************************************************/
	2130
	2131	/*
[8]	2132	*@@ doshIsFileOnFAT:
	2133	* returns TRUE if pszFileName resides on
	2134	* a FAT drive. Note that pszFileName must
	2135	* be fully qualified (i.e. the drive letter
	2136	* must be the first character), or this will
	2137	* return garbage.
[385]	2138	*
	2139	*@@changed WarpIN V1.0.20 (2010-06-05) [pr]: now compares FSD name correctly
[8]	2140	*/
	2141
	2142	BOOL doshIsFileOnFAT(const char* pcszFileName)
	2143	{
	2144	BOOL brc = FALSE;
	2145	CHAR szName[5];
	2146
[159]	2147	APIRET arc;
[8]	2148	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
	2149	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
	2150	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
	2151
	2152	szName[0] = pcszFileName[0]; // copy drive letter
	2153	szName[1] = ':';
	2154	szName[2] = '\0';
	2155
[159]	2156	if (!(arc = DosQueryFSAttach(szName, // logical drive of attached FS
	2157	0, // ulOrdinal, ignored for FSAIL_QUERYNAME
	2158	FSAIL_QUERYNAME, // return data for a Drive or Device
	2159	pfsqBuffer, // returned data
	2160	&cbBuffer))) // returned data length
[8]	2161	{
	2162	// The data for the last three fields in the FSQBUFFER2
	2163	// structure are stored at the offset of fsqBuffer.szName.
	2164	// Each data field following fsqBuffer.szName begins
	2165	// immediately after the previous item.
[123]	2166	if (!strncmp((PSZ)&(pfsqBuffer->szName) + pfsqBuffer->cbName + 1,
	2167	"FAT",
[385]	2168	pfsqBuffer->cbFSDName))
[8]	2169	brc = TRUE;
	2170	}
	2171
[167]	2172	return brc;
[8]	2173	}
	2174
	2175	/*
	2176	*@@ doshQueryFileSize:
	2177	* returns the size of an already opened file
	2178	* or 0 upon errors.
	2179	* Use doshQueryPathSize to query the size of
	2180	* any file.
[113]	2181	*
	2182	*@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
[8]	2183	*/
	2184
[123]	2185	APIRET doshQueryFileSize(HFILE hFile, // in: file handle
	2186	PULONG pulSize) // out: file size (ptr can be NULL)
[8]	2187	{
[113]	2188	APIRET arc;
[8]	2189	FILESTATUS3 fs3;
[113]	2190	if (!(arc = DosQueryFileInfo(hFile, FIL_STANDARD, &fs3, sizeof(fs3))))
[123]	2191	if (pulSize)
	2192	*pulSize = fs3.cbFile;
[167]	2193	return arc;
[8]	2194	}
	2195
	2196	/*
	2197	*@@ doshQueryPathSize:
	2198	* returns the size of any file,
	2199	* or 0 if the file could not be
	2200	* found.
[123]	2201	*
[8]	2202	* Use doshQueryFileSize instead to query the
	2203	* size if you have a HFILE.
[113]	2204	*
[123]	2205	* Otherwise this returns:
	2206	*
	2207	* -- ERROR_FILE_NOT_FOUND
	2208	* -- ERROR_PATH_NOT_FOUND
	2209	* -- ERROR_SHARING_VIOLATION
	2210	* -- ERROR_FILENAME_EXCED_RANGE
	2211	* -- ERROR_INVALID_PARAMETER
	2212	*
[113]	2213	*@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
[8]	2214	*/
	2215
[123]	2216	APIRET doshQueryPathSize(PCSZ pcszFile, // in: filename
	2217	PULONG pulSize) // out: file size (ptr can be NULL)
[8]	2218	{
[113]	2219	APIRET arc;
[123]	2220
	2221	if (pcszFile) // V0.9.16 (2001-12-08) [umoeller]
	2222	{
	2223	FILESTATUS3 fs3;
	2224	if (!(arc = DosQueryPathInfo((PSZ)pcszFile, FIL_STANDARD, &fs3, sizeof(fs3))))
	2225	if (pulSize)
	2226	*pulSize = fs3.cbFile;
	2227	}
	2228	else
	2229	arc = ERROR_INVALID_PARAMETER;
	2230
[167]	2231	return arc;
[8]	2232	}
	2233
	2234	/*
	2235	*@@ doshQueryPathAttr:
	2236	* returns the file attributes of pszFile,
	2237	* which can be fully qualified. The
	2238	* attributes will be stored in *pulAttr.
	2239	* pszFile can also specify a directory,
	2240	* although not all attributes make sense
	2241	* for directories.
	2242	*
	2243	* fAttr can be:
	2244	* -- FILE_ARCHIVED
	2245	* -- FILE_READONLY
	2246	* -- FILE_SYSTEM
	2247	* -- FILE_HIDDEN
	2248	*
[63]	2249	* This returns the APIRET of DosQueryPathInfo.
[8]	2250	* *pulAttr is only valid if NO_ERROR is
	2251	* returned.
	2252	*
[123]	2253	* Otherwise this returns:
	2254	*
	2255	* -- ERROR_FILE_NOT_FOUND
	2256	* -- ERROR_PATH_NOT_FOUND
	2257	* -- ERROR_SHARING_VIOLATION
	2258	* -- ERROR_FILENAME_EXCED_RANGE
	2259	*
[8]	2260	*@@added V0.9.0 [umoeller]
	2261	*/
	2262
	2263	APIRET doshQueryPathAttr(const char* pcszFile, // in: file or directory name
[123]	2264	PULONG pulAttr) // out: attributes (ptr can be NULL)
[8]	2265	{
	2266	FILESTATUS3 fs3;
[123]	2267	APIRET arc;
	2268
	2269	if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
[8]	2270	FIL_STANDARD,
	2271	&fs3,
[123]	2272	sizeof(fs3))))
[8]	2273	{
	2274	if (pulAttr)
	2275	*pulAttr = fs3.attrFile;
	2276	}
	2277
[167]	2278	return arc;
[8]	2279	}
	2280
	2281	/*
	2282	*@@ doshSetPathAttr:
	2283	* sets the file attributes of pszFile,
	2284	* which can be fully qualified.
	2285	* pszFile can also specify a directory,
	2286	* although not all attributes make sense
	2287	* for directories.
	2288	*
	2289	* fAttr can be:
	2290	* -- FILE_ARCHIVED
	2291	* -- FILE_READONLY
	2292	* -- FILE_SYSTEM
	2293	* -- FILE_HIDDEN
	2294	*
	2295	* Note that this simply sets all the given
	2296	* attributes; the existing attributes
	2297	* are lost.
	2298	*
	2299	* This returns the APIRET of DosQueryPathInfo.
	2300	*/
	2301
	2302	APIRET doshSetPathAttr(const char* pcszFile, // in: file or directory name
	2303	ULONG ulAttr) // in: new attributes
	2304	{
[123]	2305	APIRET arc;
	2306
	2307	if (pcszFile)
	2308	{
	2309	FILESTATUS3 fs3;
	2310	if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
	2311	FIL_STANDARD,
	2312	&fs3,
	2313	sizeof(fs3))))
	2314	{
	2315	fs3.attrFile = ulAttr;
	2316	arc = DosSetPathInfo((PSZ)pcszFile,
[8]	2317	FIL_STANDARD,
	2318	&fs3,
[123]	2319	sizeof(fs3),
	2320	DSPI_WRTTHRU);
	2321	}
	2322	}
	2323	else
	2324	arc = ERROR_INVALID_PARAMETER;
[8]	2325
[167]	2326	return arc;
[8]	2327	}
	2328
	2329	/*
[234]	2330	*@@ FindEAValue:
	2331	* returns the pointer to the EA value
	2332	* if the EA with the given name exists
	2333	* in the given FEA2LIST.
	2334	*
	2335	* Within the FEA structure
	2336	*
	2337	+ typedef struct _FEA2 {
	2338	+ ULONG oNextEntryOffset; // Offset to next entry.
	2339	+ BYTE fEA; // Extended attributes flag.
	2340	+ BYTE cbName; // Length of szName, not including NULL.
	2341	+ USHORT cbValue; // Value length.
	2342	+ CHAR szName[1]; // Extended attribute name.
	2343	+ } FEA2;
	2344	*
	2345	* the EA value starts right after szName (plus its null
	2346	* terminator). The first USHORT of the value should
	2347	* normally signify the type of the EA, e.g. EAT_ASCII.
	2348	* This returns a pointer to that type USHORT.
	2349	*
	2350	*@@added V0.9.16 (2001-10-25) [umoeller]
	2351	*@@changed V1.0.1 (2002-12-08) [umoeller]: moved this here from XWorkplace code, renamed from fsysFindEAValue
	2352	*/
	2353
	2354	PBYTE doshFindEAValue(PFEA2LIST pFEA2List2, // in: file EA list
	2355	PCSZ pcszEAName, // in: EA name to search for (e.g. ".LONGNAME")
	2356	PUSHORT pcbValue) // out: length of value (ptr can be NULL)
	2357	{
	2358	ULONG ulEANameLen;
	2359
	2360	/*
	2361	typedef struct _FEA2LIST {
	2362	ULONG cbList; // Total bytes of structure including full list.
	2363	// Apparently, if EAs aren't supported, this
	2364	// is == sizeof(ULONG).
	2365	FEA2 list[1]; // Variable-length FEA2 structures.
	2366	} FEA2LIST;
	2367
	2368	typedef struct _FEA2 {
	2369	ULONG oNextEntryOffset; // Offset to next entry.
	2370	BYTE fEA; // Extended attributes flag.
	2371	BYTE cbName; // Length of szName, not including NULL.
	2372	USHORT cbValue; // Value length.
	2373	CHAR szName[1]; // Extended attribute name.
	2374	} FEA2;
	2375	*/
	2376
	2377	if (!pFEA2List2)
	2378	return NULL;
	2379
	2380	if ( (pFEA2List2->cbList > sizeof(ULONG))
	2381	// FAT32 and CDFS return 4 for anything here, so
	2382	// we better not mess with anything else; I assume
	2383	// any FS which doesn't support EAs will do so then
	2384	&& (pcszEAName)
	2385	&& (ulEANameLen = strlen(pcszEAName))
	2386	)
	2387	{
	2388	PFEA2 pThis = &pFEA2List2->list[0];
	2389	// maintain a current offset so we will never
	2390	// go beyond the end of the buffer accidentally...
	2391	// who knows what these stupid EA routines return!
	2392	ULONG ulOfsThis = sizeof(ULONG),
	2393	ul = 0;
	2394
	2395	while (ulOfsThis < pFEA2List2->cbList)
	2396	{
	2397	if ( (ulEANameLen == pThis->cbName)
	2398	&& (!memcmp(pThis->szName,
	2399	pcszEAName,
	2400	ulEANameLen))
	2401	)
	2402	{
	2403	if (pThis->cbValue)
	2404	{
	2405	PBYTE pbValue = (PBYTE)pThis
	2406	+ sizeof(FEA2)
	2407	+ pThis->cbName;
	2408	if (pcbValue)
	2409	*pcbValue = pThis->cbValue;
	2410	return pbValue;
	2411	}
	2412	else
	2413	// no value:
	2414	return NULL;
	2415	}
	2416
	2417	if (!pThis->oNextEntryOffset)
	2418	// this was the last entry:
	2419	return NULL;
	2420
	2421	ulOfsThis += pThis->oNextEntryOffset;
	2422
	2423	pThis = (PFEA2)(((PBYTE)pThis) + pThis->oNextEntryOffset);
	2424	ul++;
	2425	} // end while
	2426	} // end if ( (pFEA2List2->cbList > sizeof(ULONG)) ...
	2427
	2428	return NULL;
	2429	}
	2430
	2431	/*
	2432	*@@ doshQueryLongname:
	2433	* attempts to find the value of the .LONGNAME EA in the
	2434	* given FEALIST and stores it in the pszLongname buffer,
	2435	* which must be CCHMAXPATH in size.
	2436	*
	2437	* Returns TRUE if a .LONGNAME was found and copied.
	2438	*
	2439	*@@added V0.9.16 (2001-10-25) [umoeller]
	2440	*@@changed V1.0.1 (2002-12-08) [umoeller]: moved this here from XWorkplace code, renamed from DecodeLongname
	2441	*/
	2442
	2443	BOOL doshQueryLongname(PFEA2LIST pFEA2List2,
	2444	PSZ pszLongname, // out: .LONGNAME if TRUE is returned
	2445	PULONG pulNameLen) // out: length of .LONGNAME string
	2446	{
	2447	PBYTE pbValue;
	2448	if (pbValue = doshFindEAValue(pFEA2List2,
	2449	".LONGNAME",
	2450	NULL))
	2451	{
	2452	PUSHORT pusType = (PUSHORT)pbValue;
	2453	if (*pusType == EAT_ASCII)
	2454	{
	2455	// CPREF: first word after EAT_ASCII specifies length
	2456	PUSHORT pusStringLength = pusType + 1; // pbValue + 2
	2457	if (*pusStringLength)
	2458	{
	2459	ULONG cb = _min(*pusStringLength, CCHMAXPATH - 1);
	2460	memcpy(pszLongname,
	2461	pbValue + 4,
	2462	cb);
	2463	pszLongname[cb] = '\0';
	2464	*pulNameLen = cb;
	2465	return TRUE;
	2466	}
	2467	}
	2468	}
	2469
	2470	return FALSE;
	2471	}
	2472
	2473	/*
[153]	2474	*@@category: Helpers\Control program helpers\File management\XFILEs
	2475	*/
	2476
	2477	/* ******************************************************************
[81]	2478	*
[153]	2479	* XFILEs
[81]	2480	*
[153]	2481	********************************************************************/
[81]	2482
[127]	2483	/*
[113]	2484	* doshOpen:
	2485	* wrapper around DosOpen for simpler opening
	2486	* of files.
	2487	*
	2488	* ulOpenMode determines the mode to open the
[123]	2489	* file in (fptr specifies the position after
	2490	* the open):
[113]	2491	*
[123]	2492	+ +-------------------------+------+------------+-----------+
	2493	+ \| ulOpenMode \| mode \| if exists \| if new \|
	2494	+ +-------------------------+------+------------+-----------+
	2495	+ \| XOPEN_READ_EXISTING \| read \| opens \| fails \|
	2496	+ \| \| \| fptr = 0 \| \|
	2497	+ +-------------------------+------+------------+-----------+
[127]	2498	+ \| XOPEN_READWRITE_EXISTING r/w \| opens \| fails \|
	2499	+ \| \| \| fptr = 0 \| \|
	2500	+ +-------------------------+------+------------+-----------+
[123]	2501	+ \| XOPEN_READWRITE_APPEND \| r/w \| opens, \| creates \|
	2502	+ \| \| \| appends \| \|
	2503	+ \| \| \| fptr = end \| fptr = 0 \|
	2504	+ +-------------------------+------+------------+-----------+
	2505	+ \| XOPEN_READWRITE_NEW \| r/w \| replaces \| creates \|
	2506	+ \| \| \| fptr = 0 \| fptr = 0 \|
	2507	+ +-------------------------+------+------------+-----------+
[113]	2508	*
[123]	2509	* In addition, you can OR one of the above values with
	2510	* the XOPEN_BINARY flag:
[121]	2511	*
	2512	* -- If XOPEN_BINARY is set, no conversion is performed
	2513	* on read and write.
	2514	*
	2515	* -- If XOPEN_BINARY is _not_ set, all \n chars are
	2516	* converted to \r\n on write.
	2517	*
[113]	2518	* *ppFile receives a new XFILE structure describing
	2519	* the open file, if NO_ERROR is returned.
	2520	*
[123]	2521	* The file pointer is then set to the beginning of the
	2522	* file _unless_ XOPEN_READWRITE_APPEND was specified;
	2523	* in that case only, the file pointer is set to the
	2524	* end of the file so data can be appended (see above).
	2525	*
	2526	* Otherwise this returns:
	2527	*
	2528	* -- ERROR_FILE_NOT_FOUND
	2529	* -- ERROR_PATH_NOT_FOUND
	2530	* -- ERROR_SHARING_VIOLATION
	2531	* -- ERROR_FILENAME_EXCED_RANGE
	2532	*
	2533	* -- ERROR_NOT_ENOUGH_MEMORY
	2534	* -- ERROR_INVALID_PARAMETER
	2535	*
[113]	2536	*@@added V0.9.16 (2001-10-19) [umoeller]
[126]	2537	*@@changed V0.9.16 (2001-12-18) [umoeller]: fixed error codes
[241]	2538	*@@changed V1.0.1 (2003-01-10) [umoeller]: now allowing read for all modes
[257]	2539	*@@changed V1.0.2 (2003-11-13) [umoeller]: optimized; now calling doshQueryPathSize only on failure
[113]	2540	*/
	2541
[116]	2542	APIRET doshOpen(PCSZ pcszFilename, // in: filename to open
[121]	2543	ULONG flOpenMode, // in: XOPEN_* mode
[113]	2544	PULONG pcbFile, // in: new file size (if new file is created)
	2545	// out: file size
	2546	PXFILE *ppFile)
	2547	{
[153]	2548	APIRET arc = NO_ERROR;
[113]	2549
[126]	2550	ULONG fsOpenFlags = 0,
	2551	fsOpenMode = OPEN_FLAGS_FAIL_ON_ERROR
	2552	\| OPEN_FLAGS_NO_LOCALITY
	2553	\| OPEN_FLAGS_NOINHERIT;
	2554
	2555	switch (flOpenMode & XOPEN_ACCESS_MASK)
[113]	2556	{
[126]	2557	case XOPEN_READ_EXISTING:
	2558	fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
	2559	\| OPEN_ACTION_OPEN_IF_EXISTS;
	2560	fsOpenMode \|= OPEN_SHARE_DENYWRITE
	2561	\| OPEN_ACCESS_READONLY;
[113]	2562
[126]	2563	// run this first, because if the file doesn't
	2564	// exists, DosOpen only returns ERROR_OPEN_FAILED,
	2565	// which isn't that meaningful
	2566	// V0.9.16 (2001-12-08) [umoeller]
[257]	2567	/* arc = doshQueryPathSize(pcszFilename,
	2568	pcbFile); */
	2569	// moved this down V1.0.2 (2003-11-13) [umoeller]
[126]	2570	break;
[113]	2571
[127]	2572	case XOPEN_READWRITE_EXISTING:
	2573	fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
	2574	\| OPEN_ACTION_OPEN_IF_EXISTS;
	2575	fsOpenMode \|= OPEN_SHARE_DENYWRITE
	2576	\| OPEN_ACCESS_READWRITE;
	2577
[257]	2578	/* arc = doshQueryPathSize(pcszFilename,
	2579	pcbFile); */
	2580	// moved this down V1.0.2 (2003-11-13) [umoeller]
[127]	2581	break;
	2582
[126]	2583	case XOPEN_READWRITE_APPEND:
	2584	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
	2585	\| OPEN_ACTION_OPEN_IF_EXISTS;
[241]	2586	fsOpenMode \|= OPEN_SHARE_DENYWRITE // OPEN_SHARE_DENYREADWRITE V1.0.1 (2003-01-10) [umoeller]
[126]	2587	\| OPEN_ACCESS_READWRITE;
	2588	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_APPEND"));
	2589	break;
[121]	2590
[126]	2591	case XOPEN_READWRITE_NEW:
	2592	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
	2593	\| OPEN_ACTION_REPLACE_IF_EXISTS;
[241]	2594	fsOpenMode \|= OPEN_SHARE_DENYWRITE // OPEN_SHARE_DENYREADWRITE V1.0.1 (2003-01-10) [umoeller]
[126]	2595	\| OPEN_ACCESS_READWRITE;
	2596	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_NEW"));
	2597	break;
	2598	}
[113]	2599
[257]	2600	if ( (!arc)
	2601	&& fsOpenFlags
	2602	&& pcbFile
	2603	&& ppFile
	2604	)
[126]	2605	{
	2606	PXFILE pFile;
	2607	if (pFile = NEW(XFILE))
[113]	2608	{
[126]	2609	ULONG ulAction;
[113]	2610
[126]	2611	ZERO(pFile);
[113]	2612
[126]	2613	// copy open flags
	2614	pFile->flOpenMode = flOpenMode;
[121]	2615
[126]	2616	if (!(arc = DosOpen((PSZ)pcszFilename,
	2617	&pFile->hf,
	2618	&ulAction,
	2619	*pcbFile,
	2620	FILE_ARCHIVED,
	2621	fsOpenFlags,
	2622	fsOpenMode,
	2623	NULL))) // EAs
	2624	{
	2625	// alright, got the file:
[113]	2626
[126]	2627	if ( (ulAction == FILE_EXISTED)
	2628	&& ((flOpenMode & XOPEN_ACCESS_MASK) == XOPEN_READWRITE_APPEND)
	2629	)
	2630	// get its size and set ptr to end for append
	2631	arc = DosSetFilePtr(pFile->hf,
	2632	0,
	2633	FILE_END,
	2634	pcbFile);
	2635	else
	2636	arc = doshQueryFileSize(pFile->hf,
[113]	2637	pcbFile);
[126]	2638	// file ptr is at beginning
[113]	2639
[131]	2640	#ifdef DEBUG_DOSOPEN
[126]	2641	if (arc)
	2642	_Pmpf((__FUNCTION__ ": DosSetFilePtr/queryfilesize returned %d for %s",
	2643	arc, pcszFilename));
[131]	2644	#endif
[123]	2645
[126]	2646	// store file size
	2647	pFile->cbInitial
	2648	= pFile->cbCurrent
	2649	= *pcbFile;
[129]	2650
	2651	pFile->pszFilename = strdup(pcszFilename);
[113]	2652	}
	2653	else
[257]	2654	{
	2655	#ifdef DEBUG_DOSOPEN
	2656	_Pmpf((__FUNCTION__ ": DosOpen returned %d for %s",
[126]	2657	arc, pcszFilename));
[257]	2658	#endif
[126]	2659
[257]	2660	// open failed: if the file doesn't exist, DosOpen only
	2661	// returns OPEN_FAILED, while ERROR_FILE_NOT_FOUND would
	2662	// be a bit more informative
	2663	// (this check used to be before DosOpen, but is a bit
	2664	// excessive and should only be run if we really have no open)
	2665	if (arc == ERROR_OPEN_FAILED)
	2666	arc = doshQueryPathSize(pcszFilename,
	2667	pcbFile);
	2668	}
	2669
[126]	2670	if (arc)
	2671	doshClose(&pFile);
	2672	else
	2673	*ppFile = pFile;
[113]	2674	}
	2675	else
[126]	2676	arc = ERROR_NOT_ENOUGH_MEMORY;
[113]	2677	}
[126]	2678	else
[153]	2679	if (!arc) // V0.9.19 (2002-04-02) [umoeller]
	2680	arc = ERROR_INVALID_PARAMETER;
[113]	2681
[167]	2682	return arc;
[113]	2683	}
	2684
	2685	/*
[127]	2686	*@@ doshReadAt:
	2687	* reads cb bytes from the position specified by
	2688	* lOffset into the buffer pointed to by pbData,
	2689	* which should be cb bytes in size.
	2690	*
	2691	* Note that lOffset is always considered to
	2692	* be from the beginning of the file (FILE_BEGIN
	2693	* method).
	2694	*
[129]	2695	* This implements a small cache so that several
	2696	* calls with a near offset will not touch the
	2697	* disk always. The cache has been optimized for
	2698	* the exeh* functions and works quite nicely
	2699	* there.
	2700	*
	2701	* Note that the position of the file pointer is
	2702	* undefined after calling this function because
	2703	* the data might have been returned from the
	2704	* cache.
	2705	*
[131]	2706	* fl may be any combination of the following:
	2707	*
	2708	* -- DRFL_NOCACHE: do not fill the cache with
	2709	* new data if the data is not in the cache
	2710	* currently.
	2711	*
	2712	* -- DRFL_FAILIFLESS: return ERROR_NO_DATA
	2713	* if the data returned by DosRead is less
	2714	* than what was specified. This might
	2715	* simplify error handling.
	2716	*
[127]	2717	*@@added V0.9.13 (2001-06-14) [umoeller]
	2718	*@@changed V0.9.16 (2001-12-18) [umoeller]: now with XFILE, and always using FILE_BEGIN
[257]	2719	*@@changed V0.9.19 (2002-04-02) [umoeller]: added params checking
	2720	*@@changed V1.0.2 (2003-11-13) [umoeller]: optimized cache (using realloc)
[127]	2721	*/
	2722
	2723	APIRET doshReadAt(PXFILE pFile,
[131]	2724	ULONG ulOffset, // in: offset to read from (from beginning of file)
[153]	2725	PULONG pcb, // in: bytes to read, out: bytes read (req.)
[131]	2726	PBYTE pbData, // out: read buffer (must be cb bytes)
	2727	ULONG fl) // in: DRFL_* flags
[127]	2728	{
[135]	2729	APIRET arc = NO_ERROR;
[153]	2730	ULONG cb;
[127]	2731	ULONG ulDummy;
	2732
[153]	2733	if (!pFile \|\| !pcb)
	2734	// V0.9.19 (2002-04-02) [umoeller]
	2735	return ERROR_INVALID_PARAMETER;
	2736
	2737	cb = *pcb;
	2738	*pcb = 0;
	2739
	2740	// check if we have the data in the cache already;
	2741
	2742	if ( (pFile->pbCache)
	2743	// first byte must be in cache
	2744	&& (ulOffset >= pFile->ulReadFrom)
	2745	// last byte must be in cache
	2746	&& ( ulOffset + cb
	2747	<= pFile->ulReadFrom + pFile->cbCache
	2748	)
	2749	)
[127]	2750	{
[153]	2751	// alright, return data from cache simply
	2752	ULONG ulOfsInCache = ulOffset - pFile->ulReadFrom;
[127]	2753
[153]	2754	memcpy(pbData,
	2755	pFile->pbCache + ulOfsInCache,
	2756	cb);
	2757	*pcb = cb;
[129]	2758
[153]	2759	#ifdef DEBUG_DOSOPEN
	2760	_Pmpf((__FUNCTION__ " %s: data is fully in cache",
	2761	pFile->pszFilename));
	2762	_Pmpf((" caller wants %d bytes from %d",
	2763	cb, ulOffset));
	2764	_Pmpf((" we got %d bytes from %d",
	2765	pFile->cbCache, pFile->ulReadFrom));
	2766	_Pmpf((" so copied %d bytes from cache ofs %d",
	2767	cb, ulOfsInCache));
	2768	#endif
	2769	}
	2770	else
	2771	{
	2772	// data is not in cache:
	2773	// check how much it is... for small amounts,
	2774	// we load the cache first
	2775	if ( (cb <= 4096 - 512)
	2776	&& (!(fl & DRFL_NOCACHE))
[129]	2777	)
[127]	2778	{
[131]	2779	#ifdef DEBUG_DOSOPEN
[153]	2780	_Pmpf((__FUNCTION__ " %s: filling cache anew",
	2781	pFile->pszFilename));
[129]	2782	_Pmpf((" caller wants %d bytes from %d",
	2783	cb, ulOffset));
[131]	2784	#endif
[127]	2785
[153]	2786	// OK, then fix the offset to read from
	2787	// to a multiple of 512 to get a full sector
	2788	pFile->ulReadFrom = ulOffset / 512L * 512L;
	2789	// and read 4096 bytes always plus the
	2790	// value we cut off above
	2791	pFile->cbCache = 4096;
[129]	2792
[153]	2793	#ifdef DEBUG_DOSOPEN
	2794	_Pmpf((" getting %d bytes from %d",
	2795	pFile->cbCache, pFile->ulReadFrom));
	2796	#endif
[129]	2797
[257]	2798	#if 0
[153]	2799	// free old cache
	2800	if (pFile->pbCache)
	2801	free(pFile->pbCache);
[129]	2802
[153]	2803	// allocate new cache
	2804	if (!(pFile->pbCache = (PBYTE)malloc(pFile->cbCache)))
[257]	2805	#else
	2806	// realloc is better V1.0.2 (2003-11-13) [umoeller]
	2807	if (!(pFile->pbCache = (PBYTE)realloc(pFile->pbCache,
	2808	pFile->cbCache)))
	2809	#endif
[153]	2810	arc = ERROR_NOT_ENOUGH_MEMORY;
[129]	2811	else
	2812	{
[153]	2813	ULONG ulOfsInCache = 0;
[131]	2814
[129]	2815	if (!(arc = DosSetFilePtr(pFile->hf,
[153]	2816	(LONG)pFile->ulReadFrom,
[129]	2817	FILE_BEGIN,
	2818	&ulDummy)))
	2819	{
	2820	if (!(arc = DosRead(pFile->hf,
[153]	2821	pFile->pbCache,
	2822	pFile->cbCache,
[129]	2823	&ulDummy)))
[131]	2824	{
[153]	2825	// got data:
	2826	#ifdef DEBUG_DOSOPEN
	2827	_Pmpf((" %d bytes read", ulDummy));
	2828	#endif
	2829
	2830	pFile->cbCache = ulDummy;
	2831
	2832	// check bounds
	2833	ulOfsInCache = ulOffset - pFile->ulReadFrom;
	2834
	2835	/*
	2836	if (ulOfsInCache + cb > pFile->cbCache)
	2837	{
	2838	cb = pFile->cbCache - ulOfsInCache;
	2839	if (fl & DRFL_FAILIFLESS)
	2840	arc = ERROR_NO_DATA;
	2841	}
	2842	*/
[131]	2843	}
[129]	2844	}
[153]	2845
	2846	if (!arc)
	2847	{
	2848	// copy to caller
	2849	memcpy(pbData,
	2850	pFile->pbCache + ulOfsInCache,
	2851	cb);
	2852	*pcb = cb;
	2853
	2854	#ifdef DEBUG_DOSOPEN
	2855	_Pmpf((" so copied %d bytes from cache ofs %d",
	2856	cb, ulOfsInCache));
	2857	#endif
	2858	}
	2859	else
	2860	{
	2861	free(pFile->pbCache);
	2862	pFile->pbCache = NULL;
	2863	}
	2864	} // end else if (!(pFile->pbCache = (PBYTE)malloc(pFile->cbCache)))
	2865	}
	2866	else
	2867	{
	2868	// read uncached:
	2869	#ifdef DEBUG_DOSOPEN
	2870	_Pmpf((" " __FUNCTION__ " %s: reading uncached",
	2871	pFile->pszFilename));
	2872	_Pmpf((" caller wants %d bytes from %d",
	2873	cb, ulOffset));
	2874	#endif
	2875
	2876	if (!(arc = DosSetFilePtr(pFile->hf,
	2877	(LONG)ulOffset,
	2878	FILE_BEGIN,
	2879	&ulDummy)))
	2880	{
	2881	if (!(arc = DosRead(pFile->hf,
	2882	pbData,
	2883	cb,
	2884	&ulDummy)))
	2885	{
	2886	if ( (fl & DRFL_FAILIFLESS)
	2887	&& (ulDummy != cb)
	2888	)
	2889	arc = ERROR_NO_DATA;
	2890	else
	2891	*pcb = ulDummy; // bytes read
	2892	}
[129]	2893	}
	2894	}
[127]	2895	}
	2896
[167]	2897	return arc;
[127]	2898	}
	2899
	2900	/*
[113]	2901	*@@ doshWrite:
	2902	* writes the specified data to the file.
	2903	* If (cb == 0), this runs strlen on pcsz
	2904	* to find out the length.
	2905	*
[121]	2906	* If the file is not in binary mode, all
	2907	* \n chars are converted to \r\n before
	2908	* writing.
	2909	*
[127]	2910	* Note that this expects that the file
	2911	* pointer is at the end of the file, or
	2912	* you will get garbage.
	2913	*
[113]	2914	*@@added V0.9.16 (2001-10-19) [umoeller]
[121]	2915	*@@changed V0.9.16 (2001-12-02) [umoeller]: added XOPEN_BINARY \r\n support
[122]	2916	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
[241]	2917	*@@changed V1.0.1 (2003-01-10) [umoeller]: now forcing DosSetFileSize
[113]	2918	*/
	2919
	2920	APIRET doshWrite(PXFILE pFile,
[127]	2921	ULONG cb,
	2922	PCSZ pbData)
[113]	2923	{
[121]	2924	APIRET arc = NO_ERROR;
[127]	2925	if ((!pFile) \|\| (!pbData))
[113]	2926	arc = ERROR_INVALID_PARAMETER;
	2927	else
	2928	{
	2929	if (!cb)
[127]	2930	cb = strlen(pbData);
[113]	2931
	2932	if (!cb)
	2933	arc = ERROR_INVALID_PARAMETER;
	2934	else
[121]	2935	{
	2936	PSZ pszNew = NULL;
	2937
	2938	if (!(pFile->flOpenMode & XOPEN_BINARY))
[113]	2939	{
[121]	2940	// convert all \n to \r\n:
	2941	// V0.9.16 (2001-12-02) [umoeller]
[113]	2942
[121]	2943	// count all \n first
	2944	ULONG cNewLines = 0;
[127]	2945	PCSZ pSource = pbData;
[121]	2946	ULONG ul;
	2947	for (ul = 0;
	2948	ul < cb;
	2949	ul++)
	2950	{
	2951	if (*pSource++ == '\n')
	2952	cNewLines++;
	2953	}
	2954
	2955	if (cNewLines)
	2956	{
	2957	// we have '\n' chars:
	2958	// then we need just as many \r chars inserted
	2959	ULONG cbNew = cb + cNewLines;
	2960	if (!(pszNew = (PSZ)malloc(cbNew)))
	2961	arc = ERROR_NOT_ENOUGH_MEMORY;
	2962	else
	2963	{
	2964	PSZ pTarget = pszNew;
[127]	2965	pSource = pbData;
[121]	2966	for (ul = 0;
	2967	ul < cb;
	2968	ul++)
	2969	{
	2970	CHAR c = *pSource++;
	2971	if (c == '\n')
	2972	*pTarget++ = '\r';
	2973	*pTarget++ = c;
	2974	}
	2975
	2976	cb = cbNew;
	2977	}
	2978	}
[113]	2979	}
[121]	2980
	2981	if (!arc)
[153]	2982	{
	2983	ULONG cbWritten;
	2984	if (!(arc = DosWrite(pFile->hf,
	2985	(pszNew)
	2986	? pszNew
	2987	: (PSZ)pbData,
	2988	cb,
	2989	&cbWritten)))
[121]	2990	{
[153]	2991	pFile->cbCurrent += cbWritten;
	2992	// invalidate the cache
	2993	FREE(pFile->pbCache);
[241]	2994
	2995	// force a writeout V1.0.1 (2003-01-10) [umoeller]
	2996	DosSetFileSize(pFile->hf, pFile->cbCurrent);
[121]	2997	}
[153]	2998	}
[121]	2999
	3000	if (pszNew)
	3001	free(pszNew);
	3002	}
[113]	3003	}
	3004
[167]	3005	return arc;
[113]	3006	}
	3007
	3008	/*
[127]	3009	*@@ doshWriteAt:
	3010	* writes cb bytes (pointed to by pbData) to the
	3011	* specified file at the position lOffset (from
	3012	* the beginning of the file).
	3013	*
	3014	*@@added V0.9.13 (2001-06-14) [umoeller]
	3015	*/
	3016
	3017	APIRET doshWriteAt(PXFILE pFile,
	3018	ULONG ulOffset, // in: offset to write at
	3019	ULONG cb, // in: bytes to write
	3020	PCSZ pbData) // in: ptr to bytes to write (must be cb bytes)
	3021	{
[135]	3022	APIRET arc = NO_ERROR;
[153]	3023	ULONG cbWritten;
	3024	if (!(arc = DosSetFilePtr(pFile->hf,
	3025	(LONG)ulOffset,
	3026	FILE_BEGIN,
	3027	&cbWritten)))
[127]	3028	{
[153]	3029	if (!(arc = DosWrite(pFile->hf,
	3030	(PSZ)pbData,
	3031	cb,
	3032	&cbWritten)))
[127]	3033	{
[153]	3034	if (ulOffset + cbWritten > pFile->cbCurrent)
	3035	pFile->cbCurrent = ulOffset + cbWritten;
	3036	// invalidate the cache V0.9.19 (2002-04-02) [umoeller]
	3037	FREE(pFile->pbCache);
[127]	3038	}
	3039	}
	3040
[167]	3041	return arc;
[127]	3042	}
	3043
	3044	/*
[113]	3045	*@@ doshWriteLogEntry
	3046	* writes a log string to an XFILE, adding a
	3047	* leading timestamp before the line.
	3048	*
	3049	* The internal string buffer is limited to 2000
[121]	3050	* characters. Length checking is _not_ performed.
[122]	3051	*
	3052	*@@added V0.9.16 (2001-10-19) [umoeller]
	3053	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
[113]	3054	*/
	3055
	3056	APIRET doshWriteLogEntry(PXFILE pFile,
	3057	const char* pcszFormat,
	3058	...)
	3059	{
[122]	3060	APIRET arc = NO_ERROR;
[113]	3061
[122]	3062	if ((!pFile) \|\| (!pcszFormat))
	3063	arc = ERROR_INVALID_PARAMETER;
	3064	else
	3065	{
	3066	DATETIME dt;
	3067	CHAR szTemp[2000];
	3068	ULONG ulLength;
[113]	3069
[122]	3070	DosGetDateTime(&dt);
	3071	if (ulLength = sprintf(szTemp,
	3072	"%04d-%02d-%02d %02d:%02d:%02d:%02d ",
	3073	dt.year, dt.month, dt.day,
	3074	dt.hours, dt.minutes, dt.seconds, dt.hundredths))
[113]	3075	{
[122]	3076	if (!(arc = doshWrite(pFile,
[127]	3077	ulLength,
	3078	szTemp)))
[122]	3079	{
	3080	va_list arg_ptr;
	3081	va_start(arg_ptr, pcszFormat);
	3082	ulLength = vsprintf(szTemp, pcszFormat, arg_ptr);
	3083	va_end(arg_ptr);
[113]	3084
[122]	3085	if (pFile->flOpenMode & XOPEN_BINARY)
	3086	// if we're in binary mode, we need to add \r too
	3087	szTemp[ulLength++] = '\r';
	3088	szTemp[ulLength++] = '\n';
[113]	3089
[122]	3090	arc = doshWrite(pFile,
[127]	3091	ulLength,
	3092	szTemp);
[122]	3093	}
[113]	3094	}
	3095	}
	3096
[167]	3097	return arc;
[113]	3098	}
	3099
	3100	/*
	3101	* doshClose:
[153]	3102	* closes an XFILE opened by doshOpen and
	3103	* sets *ppFile to NULL.
[113]	3104	*
	3105	*@@added V0.9.16 (2001-10-19) [umoeller]
	3106	*/
	3107
	3108	APIRET doshClose(PXFILE *ppFile)
	3109	{
	3110	APIRET arc = NO_ERROR;
	3111	PXFILE pFile;
	3112
	3113	if ( (ppFile)
	3114	&& (pFile = *ppFile)
	3115	)
	3116	{
[153]	3117	// set the ptr to NULL
	3118	*ppFile = NULL;
[113]	3119
[153]	3120	FREE(pFile->pbCache);
	3121	FREE(pFile->pszFilename);
[113]	3122
[153]	3123	if (pFile->hf)
	3124	{
	3125	DosSetFileSize(pFile->hf, pFile->cbCurrent);
	3126	DosClose(pFile->hf);
	3127	pFile->hf = NULLHANDLE;
[113]	3128	}
	3129
	3130	free(pFile);
	3131	}
	3132	else
	3133	arc = ERROR_INVALID_PARAMETER;
	3134
[167]	3135	return arc;
[113]	3136	}
	3137
	3138	/*
[190]	3139	*@@ doshReadText:
	3140	* reads all the contents of the given XFILE into
	3141	* a newly allocated buffer. Handles Ctrl-Z properly.
	3142	*
	3143	* Implementation for doshLoadTextFile, but can
	3144	* be called separately now.
	3145	*
	3146	*@@added V0.9.20 (2002-07-19) [umoeller]
	3147	*/
	3148
	3149	APIRET doshReadText(PXFILE pFile,
	3150	PSZ* ppszContent, // out: newly allocated buffer with file's content
	3151	PULONG pcbRead) // out: size of that buffer including null byte (ptr can be NULL)
	3152	{
	3153	APIRET arc;
	3154	PSZ pszContent;
	3155
	3156	if (!(pszContent = (PSZ)malloc(pFile->cbCurrent + 1)))
	3157	arc = ERROR_NOT_ENOUGH_MEMORY;
	3158	else
	3159	{
	3160	ULONG cbRead = 0;
	3161	if (!(arc = DosRead(pFile->hf,
	3162	pszContent,
	3163	pFile->cbCurrent,
	3164	&cbRead)))
	3165	{
	3166	if (cbRead != pFile->cbCurrent)
	3167	arc = ERROR_NO_DATA;
	3168	else
	3169	{
	3170	PSZ p;
	3171	pszContent[cbRead] = '\0';
	3172
	3173	// check if we have a ctrl-z (EOF) marker
	3174	// this is present, for example, in config.sys
	3175	// after install, and stupid E.EXE writes this
	3176	// all the time when saving a file
	3177	// V0.9.18 (2002-03-08) [umoeller]
[271]	3178	// if (p = strchr(pszContent, '\26')) What the hell is this??? Octal 26 = Decimal 22 != Ctrl-Z
	3179	if (p = strchr(pszContent, '\x1A')) // V1.0.4 (2004-12-18) [pr]
[190]	3180	{
	3181	*p = '\0';
	3182	cbRead = p - pszContent;
	3183	}
	3184
	3185	*ppszContent = pszContent;
	3186	if (pcbRead)
	3187	*pcbRead = cbRead + 1;
	3188	}
	3189	}
	3190
	3191	if (arc)
	3192	free(pszContent);
	3193	}
	3194
	3195	return arc;
	3196	}
	3197
	3198	/*
[23]	3199	*@@ doshLoadTextFile:
[8]	3200	* reads a text file from disk, allocates memory
	3201	* via malloc() and sets a pointer to this
	3202	* buffer (or NULL upon errors).
	3203	*
[129]	3204	* This allocates one extra byte to make the
	3205	* buffer null-terminated always. The buffer
	3206	* is _not_ converted WRT the line format.
	3207	*
[146]	3208	* If CTRL-Z (ASCII 26) is encountered in the
	3209	* content, it is set to the null character
	3210	* instead (V0.9.18).
	3211	*
[8]	3212	* This returns the APIRET of DosOpen and DosRead.
[265]	3213	* If any error occurred, no buffer was allocated.
[8]	3214	* Otherwise, you should free() the buffer when
	3215	* no longer needed.
[23]	3216	*
	3217	*@@changed V0.9.7 (2001-01-15) [umoeller]: renamed from doshReadTextFile
[129]	3218	*@@changed V0.9.16 (2002-01-05) [umoeller]: added pcbRead
	3219	*@@changed V0.9.16 (2002-01-05) [umoeller]: rewritten using doshOpen
[146]	3220	*@@changed V0.9.18 (2002-03-08) [umoeller]: fixed ctrl-z (EOF) bug
[8]	3221	*/
	3222
[129]	3223	APIRET doshLoadTextFile(PCSZ pcszFile, // in: file name to read
	3224	PSZ* ppszContent, // out: newly allocated buffer with file's content
	3225	PULONG pcbRead) // out: size of that buffer including null byte (ptr can be NULL)
[8]	3226	{
[129]	3227	APIRET arc;
	3228
	3229	ULONG cbFile = 0;
	3230	PXFILE pFile = NULL;
	3231
	3232	if (!(arc = doshOpen(pcszFile,
	3233	XOPEN_READ_EXISTING,
	3234	&cbFile,
	3235	&pFile)))
	3236	{
[190]	3237	doshReadText(pFile,
	3238	ppszContent,
	3239	pcbRead);
[129]	3240	doshClose(&pFile);
	3241	}
	3242
[167]	3243	return arc;
[8]	3244	}
	3245
	3246	/*
[243]	3247	*@@ doshCreateLogFilename:
	3248	* produces a log filename in pszBuf.
	3249	* If $(LOGFILES) is set, that directory
	3250	* is used; otherwise we use the root
	3251	* directory of the boot drive.
	3252	*
	3253	*@@added V1.0.1 (2003-01-25) [umoeller]
	3254	*/
	3255
	3256	BOOL doshCreateLogFilename(PSZ pszBuf, // out: fully qualified filename
	3257	PCSZ pcszFilename, // in: short log filename
	3258	BOOL fAllowBootDrive) // in: allow creating log files on boot drive?
	3259	{
	3260	CHAR szBoot[] = "?:";
[244]	3261	#if __cplusplus // stupid OS/2 C++ prototypes
	3262	PCSZ pszLogDir;
	3263	#else
[243]	3264	PSZ pszLogDir;
[244]	3265	#endif
[243]	3266	if (DosScanEnv("LOGFILES", // new eCS 1.1 setting
	3267	&pszLogDir))
	3268	{
	3269	// variable not set:
	3270	if (!fAllowBootDrive)
	3271	return FALSE;
	3272
	3273	szBoot[0] = doshQueryBootDrive();
	3274	pszLogDir = szBoot;
	3275	}
	3276
	3277	sprintf(pszBuf,
	3278	"%s\\%s",
	3279	pszLogDir,
	3280	pcszFilename);
	3281
	3282	return TRUE;
	3283	}
	3284
	3285	/*
[8]	3286	*@@ doshCreateBackupFileName:
	3287	* creates a valid backup filename of pszExisting
	3288	* with a numerical file name extension which does
	3289	* not exist in the directory where pszExisting
	3290	* resides.
	3291	* Returns a PSZ to a new buffer which was allocated
	3292	* using malloc().
	3293	*
	3294	* <B>Example:</B> returns "C:\CONFIG.002" for input
	3295	* "C:\CONFIG.SYS" if "C:\CONFIG.001" already exists.
	3296	*
	3297	*@@changed V0.9.1 (99-12-13) [umoeller]: this crashed if pszExisting had no file extension
	3298	*/
	3299
	3300	PSZ doshCreateBackupFileName(const char* pszExisting)
	3301	{
	3302	CHAR szFilename[CCHMAXPATH];
	3303	PSZ pszLastDot;
	3304	ULONG ulCount = 1;
	3305	CHAR szCount[5];
[113]	3306	ULONG ulDummy;
[8]	3307
	3308	strcpy(szFilename, pszExisting);
[142]	3309
	3310	if (!(pszLastDot = strrchr(szFilename, '.')))
[8]	3311	// no dot in filename:
	3312	pszLastDot = szFilename + strlen(szFilename);
[142]	3313
[8]	3314	do
	3315	{
[13]	3316	sprintf(szCount, ".%03lu", ulCount);
[8]	3317	strcpy(pszLastDot, szCount);
	3318	ulCount++;
[113]	3319	} while (!doshQueryPathSize(szFilename, &ulDummy));
[8]	3320
[238]	3321	return strdup(szFilename);
[8]	3322	}
	3323
	3324	/*
[55]	3325	*@@ doshCreateTempFileName:
	3326	* produces a file name in the the specified directory
	3327	* or $(TEMP) which presently doesn't exist. This
	3328	* checks the directory for existing files, but does
	3329	* not open the temp file.
	3330	*
	3331	* If (pcszDir != NULL), we look into that directory.
	3332	* Otherwise we look into the directory specified
	3333	* by the $(TEMP) environment variable.
	3334	* If $(TEMP) is not set, $(TMP) is tried next.
	3335	*
	3336	* If the directory thus specified does not exist, the
	3337	* root directory of the boot drive is used instead.
	3338	* As a result, this function should be fairly bomb-proof.
	3339	*
	3340	* If (pcszExt != NULL), the temp file receives
	3341	* that extension, or no extension otherwise.
	3342	* Do not specify the dot in pcszExt.
	3343	*
	3344	* pszTempFileName receives the fully qualified
	3345	* file name of the temp file in that directory
	3346	* and must point to a buffer CCHMAXPATH in size.
	3347	* The file name is 8+3 compliant if pcszExt does
	3348	* not exceed three characters.
	3349	*
	3350	* If (pcszPrefix != NULL), the temp file name
	3351	* is prefixed with pcszPrefix. Since the temp
	3352	* file name must not exceed 8+3 letters, we
	3353	* can only use ( 8 - strlen(pcszPrefix ) digits
	3354	* for a random number to make the temp file name
	3355	* unique. You must therefore use a maximum of
	3356	* four characters for the prefix. Otherwise
	3357	* ERROR_INVALID_PARAMETER is returned.
	3358	*
	3359	* Example: Assuming TEMP is set to C:\TEMP,
	3360	+
[133]	3361	+ doshCreateTempFileName(szBuffer,
	3362	+ NULL, // use $(TEMP)
	3363	+ "pre", // prefix
	3364	+ "tmp") // extension
[55]	3365	+
	3366	* would produce something like "C:\TEMP\pre07FG2.tmp".
	3367	*
	3368	*@@added V0.9.9 (2001-04-04) [umoeller]
	3369	*/
	3370
	3371	APIRET doshCreateTempFileName(PSZ pszTempFileName, // out: fully q'fied temp file name
[116]	3372	PCSZ pcszDir, // in: dir or NULL for %TEMP%
	3373	PCSZ pcszPrefix, // in: prefix for temp file or NULL
	3374	PCSZ pcszExt) // in: extension (without dot) or NULL
[55]	3375	{
	3376	APIRET arc = NO_ERROR;
	3377
	3378	ULONG ulPrefixLen = (pcszPrefix)
	3379	? strlen(pcszPrefix)
	3380	: 0;
	3381
	3382	if ( (!pszTempFileName)
	3383	\|\| (ulPrefixLen > 4)
	3384	)
	3385	arc = ERROR_INVALID_PARAMETER;
	3386	else
	3387	{
	3388	CHAR szDir[CCHMAXPATH] = "";
	3389	FILESTATUS3 fs3;
	3390
	3391	const char *pcszTemp = pcszDir;
	3392
	3393	if (!pcszTemp)
	3394	{
[123]	3395	if (!(pcszTemp = getenv("TEMP")))
[55]	3396	pcszTemp = getenv("TMP");
	3397	}
	3398
	3399	if (pcszTemp) // either pcszDir or $(TEMP) or $(TMP) now
	3400	if (DosQueryPathInfo((PSZ)pcszTemp,
	3401	FIL_STANDARD,
	3402	&fs3,
	3403	sizeof(fs3)))
	3404	// TEMP doesn't exist:
	3405	pcszTemp = NULL;
	3406
	3407	if (!pcszTemp)
	3408	// not set, or doesn't exist:
	3409	// use root directory on boot drive
	3410	sprintf(szDir,
	3411	"%c:\\",
	3412	doshQueryBootDrive());
	3413	else
	3414	{
	3415	strcpy(szDir, pcszTemp);
	3416	if (szDir[strlen(szDir) - 1] != '\\')
	3417	strcat(szDir, "\\");
	3418	}
	3419
	3420	if (!szDir[0])
	3421	arc = ERROR_PATH_NOT_FOUND; // shouldn't happen
	3422	else
	3423	{
	3424	ULONG ulRandom = 0;
	3425	ULONG cAttempts = 0;
	3426
	3427	// produce random number
	3428	DosQuerySysInfo(QSV_MS_COUNT,
	3429	QSV_MS_COUNT,
	3430	&ulRandom,
	3431	sizeof(ulRandom));
	3432
	3433	do
	3434	{
	3435	CHAR szFile[20] = "",
	3436	szFullTryThis[CCHMAXPATH];
	3437
	3438	// use the lower eight hex digits of the
	3439	// system uptime as the temp dir name
	3440	sprintf(szFile,
	3441	"%08lX",
	3442	ulRandom & 0xFFFFFFFF);
	3443
	3444	// if prefix is specified, overwrite the
	3445	// first characters in the random number
	3446	if (pcszPrefix)
	3447	memcpy(szFile, pcszPrefix, ulPrefixLen);
	3448
	3449	if (pcszExt)
	3450	{
	3451	szFile[8] = '.';
	3452	strcpy(szFile + 9, pcszExt);
	3453	}
	3454
	3455	// now compose full temp file name
	3456	strcpy(szFullTryThis, szDir);
	3457	strcat(szFullTryThis, szFile);
	3458	// now we have: "C:\temp\wpiXXXXX"
	3459	if (DosQueryPathInfo(szFullTryThis,
	3460	FIL_STANDARD,
	3461	&fs3,
	3462	sizeof(fs3))
	3463	== ERROR_FILE_NOT_FOUND)
	3464	{
	3465	// file or dir doesn't exist:
	3466	// cool, we're done
	3467	strcpy(pszTempFileName, szFullTryThis);
[169]	3468	return NO_ERROR;
[55]	3469	}
	3470
	3471	// if this didn't work, raise ulRandom and try again
	3472	ulRandom += 123;
	3473
	3474	// try only 100 times, just to be sure
	3475	cAttempts++;
	3476	} while (cAttempts < 100);
	3477
	3478	// 100 loops elapsed:
	3479	arc = ERROR_BAD_FORMAT;
	3480	}
	3481	}
	3482
[167]	3483	return arc;
[55]	3484	}
	3485
	3486	/*
[8]	3487	*@@ doshWriteTextFile:
	3488	* writes a text file to disk; pszFile must contain the
	3489	* whole path and filename.
	3490	*
	3491	* An existing file will be backed up if (pszBackup != NULL),
	3492	* using doshCreateBackupFileName. In that case, pszBackup
	3493	* receives the name of the backup created, so that buffer
	3494	* should be CCHMAXPATH in size.
	3495	*
	3496	* If (pszbackup == NULL), an existing file will be overwritten.
	3497	*
	3498	* On success (NO_ERROR returned), *pulWritten receives
	3499	* the no. of bytes written.
	3500	*
	3501	*@@changed V0.9.3 (2000-05-01) [umoeller]: optimized DosOpen; added error checking; changed prototype
	3502	*@@changed V0.9.3 (2000-05-12) [umoeller]: added pszBackup
	3503	*/
	3504
	3505	APIRET doshWriteTextFile(const char* pszFile, // in: file name
	3506	const char* pszContent, // in: text to write
	3507	PULONG pulWritten, // out: bytes written (ptr can be NULL)
	3508	PSZ pszBackup) // in/out: create-backup?
	3509	{
	3510	APIRET arc = NO_ERROR;
	3511	ULONG ulWritten = 0;
	3512
	3513	if ((!pszFile) \|\| (!pszContent))
	3514	arc = ERROR_INVALID_PARAMETER;
	3515	else
	3516	{
	3517	ULONG ulAction = 0,
	3518	ulLocal = 0;
	3519	HFILE hFile = 0;
	3520
	3521	ULONG ulSize = strlen(pszContent); // exclude 0 byte
	3522
	3523	if (pszBackup)
	3524	{
	3525	PSZ pszBackup2 = doshCreateBackupFileName(pszFile);
	3526	DosCopy((PSZ)pszFile,
	3527	pszBackup2,
	3528	DCPY_EXISTING); // delete existing
	3529	strcpy(pszBackup, pszBackup2);
	3530	free(pszBackup2);
	3531	}
	3532
[113]	3533	if (!(arc = DosOpen((PSZ)pszFile,
	3534	&hFile,
	3535	&ulAction, // action taken
	3536	ulSize, // primary allocation size
	3537	FILE_ARCHIVED \| FILE_NORMAL, // file attribute
	3538	OPEN_ACTION_CREATE_IF_NEW
	3539	\| OPEN_ACTION_REPLACE_IF_EXISTS, // open flags
	3540	OPEN_FLAGS_NOINHERIT
	3541	\| OPEN_FLAGS_SEQUENTIAL // sequential, not random access
	3542	\| OPEN_SHARE_DENYWRITE // deny write mode
	3543	\| OPEN_ACCESS_WRITEONLY, // write mode
	3544	NULL))) // no EAs
[8]	3545	{
[113]	3546	if (!(arc = DosSetFilePtr(hFile,
	3547	0L,
	3548	FILE_BEGIN,
	3549	&ulLocal)))
	3550	if (!(arc = DosWrite(hFile,
	3551	(PVOID)pszContent,
	3552	ulSize,
	3553	&ulWritten)))
[8]	3554	arc = DosSetFileSize(hFile, ulSize);
	3555
	3556	DosClose(hFile);
	3557	}
	3558	} // end if ((pszFile) && (pszContent))
	3559
	3560	if (pulWritten)
	3561	*pulWritten = ulWritten;
	3562
[167]	3563	return arc;
[8]	3564	}
	3565
	3566	/*
	3567	*@@category: Helpers\Control program helpers\Directory management
[21]	3568	* directory helpers (querying, creating, deleting etc.).
[8]	3569	*/
	3570
	3571	/* ******************************************************************
[14]	3572	*
	3573	* Directory helpers
	3574	*
[8]	3575	********************************************************************/
	3576
	3577	/*
	3578	*@@ doshQueryDirExist:
	3579	* returns TRUE if the given directory
[123]	3580	* exists and really is a directory.
[8]	3581	*/
	3582
[116]	3583	BOOL doshQueryDirExist(PCSZ pcszDir)
[8]	3584	{
	3585	FILESTATUS3 fs3;
[123]	3586	APIRET arc;
	3587
	3588	if (!(arc = DosQueryPathInfo((PSZ)pcszDir,
	3589	FIL_STANDARD,
	3590	&fs3,
	3591	sizeof(fs3))))
[8]	3592	// file found:
	3593	return ((fs3.attrFile & FILE_DIRECTORY) != 0);
[238]	3594
	3595	return FALSE;
[8]	3596	}
	3597
	3598	/*
	3599	*@@ doshCreatePath:
	3600	* this creates the specified directory.
	3601	* As opposed to DosCreateDir, this
	3602	* function can create several directories
	3603	* at the same time, if the parent
	3604	* directories do not exist yet.
	3605	*/
	3606
[116]	3607	APIRET doshCreatePath(PCSZ pcszPath,
[8]	3608	BOOL fHidden) // in: if TRUE, the new directories will get FILE_HIDDEN
	3609	{
	3610	APIRET arc0 = NO_ERROR;
	3611	CHAR path[CCHMAXPATH];
	3612	CHAR *cp, c;
	3613	ULONG cbPath;
	3614
[53]	3615	strcpy(path, pcszPath);
[8]	3616	cbPath = strlen(path);
	3617
	3618	if (path[cbPath] != '\\')
	3619	{
	3620	path[cbPath] = '\\';
[192]	3621	path[cbPath + 1] = 0;
[8]	3622	}
	3623
	3624	cp = path;
	3625	// advance past the drive letter only if we have one
	3626	if (*(cp+1) == ':')
	3627	cp += 3;
	3628
	3629	// go!
	3630	while (*cp != 0)
	3631	{
	3632	if (*cp == '\\')
	3633	{
	3634	c = *cp;
	3635	*cp = 0;
	3636	if (!doshQueryDirExist(path))
	3637	{
	3638	APIRET arc = DosCreateDir(path,
	3639	0); // no EAs
	3640	if (arc != NO_ERROR)
	3641	{
	3642	arc0 = arc;
	3643	break;
	3644	}
	3645	else
	3646	if (fHidden)
	3647	{
	3648	// hide the directory we just created
	3649	doshSetPathAttr(path, FILE_HIDDEN);
	3650	}
	3651	}
	3652	*cp = c;
	3653	}
	3654	cp++;
	3655	}
[192]	3656
[238]	3657	return arc0;
[8]	3658	}
	3659
	3660	/*
	3661	*@@ doshQueryCurrentDir:
	3662	* writes the current directory into
	3663	* the specified buffer, which should be
	3664	* CCHMAXPATH in size.
	3665	*
	3666	* As opposed to DosQueryCurrentDir, this
	3667	* includes the drive letter.
	3668	*
	3669	*@@added V0.9.4 (2000-07-22) [umoeller]
	3670	*/
	3671
	3672	APIRET doshQueryCurrentDir(PSZ pszBuf)
	3673	{
	3674	APIRET arc = NO_ERROR;
	3675	ULONG ulCurDisk = 0;
	3676	ULONG ulMap = 0;
[108]	3677	if (!(arc = DosQueryCurrentDisk(&ulCurDisk, &ulMap)))
[8]	3678	{
	3679	ULONG cbBuf = CCHMAXPATH - 3;
[142]	3680	pszBuf[0] = ulCurDisk + 'A' - 1;
	3681	pszBuf[1] = ':';
	3682	pszBuf[2] = '\\';
	3683	pszBuf[3] = '\0';
[8]	3684	arc = DosQueryCurrentDir(0, pszBuf + 3, &cbBuf);
	3685	}
	3686
[167]	3687	return arc;
[8]	3688	}
	3689
	3690	/*
	3691	*@@ doshDeleteDir:
	3692	* deletes a directory. As opposed to DosDeleteDir,
	3693	* this removes empty subdirectories and/or files
	3694	* as well.
	3695	*
	3696	* flFlags can be any combination of the following:
	3697	*
	3698	* -- DOSHDELDIR_RECURSE: recurse into subdirectories.
	3699	*
	3700	* -- DOSHDELDIR_DELETEFILES: delete all regular files
	3701	* which are found on the way.
	3702	*
	3703	* THIS IS NOT IMPLEMENTED YET.
	3704	*
	3705	* If 0 is specified, this effectively behaves just as
	3706	* DosDeleteDir.
	3707	*
	3708	* If you specify DOSHDELDIR_RECURSE only, only empty
	3709	* subdirectories are deleted as well.
	3710	*
	3711	* If you specify DOSHDELDIR_RECURSE \| DOSHDELDIR_DELETEFILES,
	3712	* this removes an entire directory tree, including all
	3713	* subdirectories and files.
	3714	*
	3715	*@@added V0.9.4 (2000-07-01) [umoeller]
[350]	3716	*@@changed WarpIN V1.0.15 (2007-03-27) [pr]: allow NULL pulDirs and pulFiles
[353]	3717	*@@changed WarpIN V1.0.16 (2007-07-28) [pr]: bump directory count on recursive delete failures @@fixes 1001
[411]	3718	*@@changed WarpIN V1.0.20 (2012-03-29) [pr]: path not found no longer an error
[8]	3719	*/
	3720
[116]	3721	APIRET doshDeleteDir(PCSZ pcszDir,
[8]	3722	ULONG flFlags,
	3723	PULONG pulDirs, // out: directories found
	3724	PULONG pulFiles) // out: files found
	3725	{
	3726	APIRET arc = NO_ERROR,
	3727	arcReturn = NO_ERROR;
	3728
	3729	HDIR hdirFindHandle = HDIR_CREATE;
	3730	FILEFINDBUF3 ffb3 = {0}; // returned from FindFirst/Next
	3731	ULONG ulResultBufLen = sizeof(FILEFINDBUF3);
	3732	ULONG ulFindCount = 1; // look for 1 file at a time
	3733
	3734	CHAR szFileMask[2*CCHMAXPATH];
	3735	sprintf(szFileMask, "%s\\*", pcszDir);
	3736
	3737	// find files
	3738	arc = DosFindFirst(szFileMask,
	3739	&hdirFindHandle, // directory search handle
	3740	FILE_ARCHIVED \| FILE_DIRECTORY \| FILE_SYSTEM
	3741	\| FILE_HIDDEN \| FILE_READONLY,
	3742	// search attributes; include all, even dirs
	3743	&ffb3, // result buffer
	3744	ulResultBufLen, // result buffer length
	3745	&ulFindCount, // number of entries to find
	3746	FIL_STANDARD); // return level 1 file info
	3747
	3748	if (arc == NO_ERROR)
	3749	{
	3750	// keep finding the next file until there are no more files
	3751	while (arc == NO_ERROR) // != ERROR_NO_MORE_FILES
	3752	{
	3753	if (ffb3.attrFile & FILE_DIRECTORY)
	3754	{
	3755	// we found a directory:
	3756
	3757	// ignore the pseudo-directories
	3758	if ( (strcmp(ffb3.achName, ".") != 0)
	3759	&& (strcmp(ffb3.achName, "..") != 0)
	3760	)
	3761	{
	3762	// real directory:
	3763	if (flFlags & DOSHDELDIR_RECURSE)
	3764	{
	3765	// recurse!
	3766	CHAR szSubDir[2*CCHMAXPATH];
	3767	sprintf(szSubDir, "%s\\%s", pcszDir, ffb3.achName);
	3768	arcReturn = doshDeleteDir(szSubDir,
	3769	flFlags,
	3770	pulDirs,
	3771	pulFiles);
	3772	// this removes ffb3.achName as well
	3773	}
	3774	else
	3775	{
	3776	// directory, but no recursion:
	3777	// report "access denied"
	3778	// (this is what OS/2 reports with DosDeleteDir as well)
	3779	arcReturn = ERROR_ACCESS_DENIED; // 5
[353]	3780	}
	3781
	3782	if (arcReturn != NO_ERROR) // WarpIN V1.0.16 (2007-07-28) [pr]
[350]	3783	if (pulDirs) // WarpIN V1.0.15 (2007-03-27) [pr]
	3784	(*pulDirs)++;
[8]	3785	}
	3786	}
	3787	else
	3788	{
	3789	// it's a file:
	3790	arcReturn = ERROR_ACCESS_DENIED;
[350]	3791	if (pulFiles) // WarpIN V1.0.15 (2007-03-27) [pr]
	3792	(*pulFiles)++;
[8]	3793	}
	3794
	3795	if (arc == NO_ERROR)
	3796	{
	3797	ulFindCount = 1; // reset find count
	3798	arc = DosFindNext(hdirFindHandle, // directory handle
	3799	&ffb3, // result buffer
	3800	ulResultBufLen, // result buffer length
	3801	&ulFindCount); // number of entries to find
	3802	}
	3803	} // endwhile
	3804
	3805	DosFindClose(hdirFindHandle); // close our find handle
	3806	}
	3807
	3808	if (arcReturn == NO_ERROR)
[411]	3809	{
[8]	3810	// success so far:
	3811	// delete our directory now
[154]	3812	arcReturn = DosDeleteDir((PSZ)pcszDir);
[411]	3813	if (arcReturn == ERROR_PATH_NOT_FOUND) // WarpIN V1.0.20 (2012-03-29) [pr]
	3814	arcReturn = NO_ERROR;
	3815	}
[8]	3816
[238]	3817	return arcReturn;
[8]	3818	}
	3819
	3820	/*
[159]	3821	*@@ doshCanonicalize:
	3822	* simplifies path specifications to remove '.'
	3823	* and '..' entries and generates a fully
	3824	* qualified path name where possible.
	3825	* File specifications are left unchanged.
	3826	*
	3827	* This returns:
	3828	*
	3829	* -- NO_ERROR: the buffers were valid.
	3830	*
	3831	* -- ERROR_INVALID_PARAMETER: the buffers
	3832	* were invalid.
	3833	*
	3834	*@@added V0.9.19 (2002-04-22) [pr]
	3835	*/
	3836
	3837	APIRET doshCanonicalize(PCSZ pcszFileIn, // in: path to canonicalize
	3838	PSZ pszFileOut, // out: canonicalized path if NO_ERROR
	3839	ULONG cbFileOut) // in: size of pszFileOut buffer
	3840	{
	3841	APIRET ulrc = NO_ERROR;
	3842	CHAR szFileTemp[CCHMAXPATH];
	3843
	3844	if (pcszFileIn && pszFileOut && cbFileOut)
	3845	{
	3846	strncpy(szFileTemp, pcszFileIn, sizeof(szFileTemp) - 1);
	3847	szFileTemp[sizeof(szFileTemp) - 1] = 0;
	3848	if ( strchr(szFileTemp, '\\')
	3849	\|\| strchr(szFileTemp, ':')
	3850	)
	3851	{
	3852	ULONG cbFileTemp = strlen(szFileTemp);
	3853
	3854	if ( (cbFileTemp > 3)
	3855	&& (szFileTemp[cbFileTemp - 1] == '\\')
	3856	)
	3857	{
	3858	szFileTemp[cbFileTemp - 1] = 0;
	3859	}
	3860
	3861	if (DosQueryPathInfo(szFileTemp,
	3862	FIL_QUERYFULLNAME,
	3863	pszFileOut,
	3864	cbFileOut))
	3865	{
	3866	pszFileOut[0] = 0;
	3867	}
	3868	}
	3869	else
	3870	{
	3871	strncpy(pszFileOut, pcszFileIn, cbFileOut - 1);
	3872	pszFileOut[cbFileOut - 1] = 0;
	3873	}
	3874	}
	3875	else
	3876	ulrc = ERROR_INVALID_PARAMETER;
	3877
	3878	return(ulrc);
	3879	}
	3880
[249]	3881	#define FINDBUFSIZE 0x10000 // 64K
	3882	#define FINDCOUNT 500
	3883
[159]	3884	/*
[249]	3885	*@@ doshForAllFiles:
	3886	* this calles pfncb for all files in a directory matching
	3887	* the given file mask.
	3888	*
	3889	* This is to avoid having to recode the typical but
	3890	* easy-to-get-wrong DosFindFirst/Next loop.
	3891	*
	3892	* pfncb must be prototyped as follows:
	3893	*
	3894	+ APIRET XWPENTRY fnMyCallback(const FILEFINDBUF3 *pfb3,
	3895	+ PVOID pvCallback)
	3896	*
	3897	* On each iteration, it receives the current file-find
	3898	* buffer in pfb3. pvCallback is constantly set to what
	3899	* was passed in to this function.
	3900	*
	3901	* The callback will get called for every file returned
	3902	* from the loop. This function will automatically
	3903	* filter out the stupid "." and ".." directory entries
	3904	* that DosFindFirst/Next always return, so the callback
	3905	* will never see those.
	3906	*
	3907	* If the callback returns any value other than NO_ERROR,
	3908	* this function aborts and returns that error. The
	3909	* exception is that if the callback returns
	3910	* ERROR_NO_MORE_FILES, this function will abort also,
	3911	* but return NO_ERROR still. This is useful if you are
	3912	* looking for a specific file and want to cancel the
	3913	* search early without provoking an error.
	3914	*
	3915	*@@added V1.0.2 (2003-02-03) [umoeller]
	3916	*/
	3917
	3918	APIRET doshForAllFiles(PCSZ pcszSearchMask, // in: search mask (e.g. "C:\dir\*.txt")
	3919	ULONG flFile, // in: any of FILE_ARCHIVED \| FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY \| FILE_DIRECTORY
	3920	FNCBFORALLFILES *pfncb, // in: address of callback function
	3921	PVOID pvCallback) // in: parameter passed to callback
	3922	{
	3923	APIRET arc = NO_ERROR;
	3924	HDIR hdirFindHandle = HDIR_CREATE;
	3925	ULONG ulFindCount = FINDCOUNT;
	3926
	3927	PBYTE pbFindBuf;
	3928
	3929	if (arc = DosAllocMem((PVOID*)&pbFindBuf,
	3930	FINDBUFSIZE,
	3931	PAG_COMMIT \| PAG_READ \| PAG_WRITE \| OBJ_TILE))
	3932	return arc;
	3933
	3934	arc = DosFindFirst((PSZ)pcszSearchMask,
	3935	&hdirFindHandle,
	3936	flFile,
	3937	pbFindBuf,
	3938	FINDBUFSIZE,
	3939	&ulFindCount,
	3940	FIL_STANDARD);
	3941
	3942	while ( (arc == NO_ERROR)
	3943	\|\| (arc == ERROR_BUFFER_OVERFLOW)
	3944	)
	3945	{
	3946	ULONG ul;
	3947	PFILEFINDBUF3 pfb3 = (PFILEFINDBUF3)pbFindBuf;
	3948
	3949	for (ul = 0;
	3950	ul < ulFindCount;
	3951	ul++)
	3952	{
	3953	// filter out the "." and ".." entries
	3954	if (!( (pfb3->attrFile & FILE_DIRECTORY)
	3955	&& (pfb3->achName[0] == '.')
	3956	&& ( (pfb3->achName[1] == '\0')
	3957	\|\| ( (pfb3->achName[1] == '.')
	3958	&& (pfb3->achName[2] == '\0')
	3959	)
	3960	)
	3961	))
	3962	{
	3963	// call callback
	3964	if (arc = pfncb(pfb3, pvCallback))
	3965	// callback returned error:
	3966	break;
	3967	}
	3968
	3969	// next item in buffer
	3970	if (pfb3->oNextEntryOffset)
	3971	pfb3 = (PFILEFINDBUF3)( (PBYTE)pfb3
	3972	+ pfb3->oNextEntryOffset
	3973	);
	3974	}
	3975
	3976	if (!arc)
	3977	{
	3978	ulFindCount = FINDCOUNT;
	3979	arc = DosFindNext(hdirFindHandle,
	3980	pbFindBuf,
	3981	FINDBUFSIZE,
	3982	&ulFindCount);
	3983	}
	3984	}
	3985
	3986	// no more files is not an error
	3987	if (arc == ERROR_NO_MORE_FILES)
	3988	arc = NO_ERROR;
	3989
	3990	DosFindClose(hdirFindHandle);
	3991
	3992	DosFreeMem(pbFindBuf);
	3993
	3994	return arc;
	3995	}
	3996
	3997	/*
[17]	3998	*@@category: Helpers\Control program helpers\Module handling
[21]	3999	* helpers for importing functions from a module (DLL).
[17]	4000	*/
	4001
	4002	/* ******************************************************************
	4003	*
	4004	* Module handling helpers
	4005	*
	4006	********************************************************************/
	4007
	4008	/*
[132]	4009	*@@ doshQueryProcAddr:
	4010	* attempts to resolve the given procedure from
	4011	* the given module name. Saves you from querying
	4012	* the module handle and all that.
	4013	*
	4014	* This is intended for resolving undocumented
	4015	* APIs from OS/2 system DLls such as PMMERGE
	4016	* and DOSCALLS. It is assumed that the specified
	4017	* module is already loaded.
	4018	*
	4019	* Returns:
	4020	*
	4021	* -- NO_ERROR
	4022	*
	4023	* -- ERROR_INVALID_NAME
	4024	*
	4025	* -- ERROR_INVALID_ORDINAL
	4026	*
	4027	* plus the error codes of DosLoadModule.
	4028	*
	4029	*@@added V0.9.16 (2002-01-13) [umoeller]
	4030	*/
	4031
	4032	APIRET doshQueryProcAddr(PCSZ pcszModuleName, // in: module name (e.g. "PMMERGE")
	4033	ULONG ulOrdinal, // in: proc ordinal
	4034	PFN *ppfn) // out: proc address
	4035	{
	4036	HMODULE hmod;
	4037	APIRET arc;
	4038	if (!(arc = DosQueryModuleHandle((PSZ)pcszModuleName,
	4039	&hmod)))
	4040	{
	4041	if ((arc = DosQueryProcAddr(hmod,
	4042	ulOrdinal,
	4043	NULL,
	4044	ppfn)))
	4045	{
	4046	// the CP programming guide and reference says use
	4047	// DosLoadModule if DosQueryProcAddr fails with this error
	4048	if (arc == ERROR_INVALID_HANDLE)
	4049	{
	4050	if (!(arc = DosLoadModule(NULL,
	4051	0,
	4052	(PSZ)pcszModuleName,
	4053	&hmod)))
	4054	{
	4055	arc = DosQueryProcAddr(hmod,
	4056	ulOrdinal,
	4057	NULL,
	4058	ppfn);
	4059	}
	4060	}
	4061	}
	4062	}
	4063
[167]	4064	return arc;
[132]	4065	}
	4066
	4067	/*
[17]	4068	*@@ doshResolveImports:
	4069	* this function loads the module called pszModuleName
	4070	* and resolves imports dynamically using DosQueryProcAddress.
	4071	*
	4072	* To specify the functions to be imported, a RESOLVEFUNCTION
	4073	* array is used. In each of the array items, specify the
	4074	* name of the function and a pointer to a function pointer
	4075	* where to store the resolved address.
	4076	*
	4077	*@@added V0.9.3 (2000-04-29) [umoeller]
	4078	*/
	4079
[132]	4080	APIRET doshResolveImports(PCSZ pcszModuleName, // in: DLL to load
[17]	4081	HMODULE *phmod, // out: module handle
[132]	4082	PCRESOLVEFUNCTION paResolves, // in/out: function resolves
[17]	4083	ULONG cResolves) // in: array item count (not array size!)
	4084	{
	4085	CHAR szName[CCHMAXPATH];
[123]	4086	APIRET arc;
	4087
	4088	if (!(arc = DosLoadModule(szName,
	4089	sizeof(szName),
[132]	4090	(PSZ)pcszModuleName,
[123]	4091	phmod)))
[17]	4092	{
	4093	ULONG ul;
	4094	for (ul = 0;
	4095	ul < cResolves;
	4096	ul++)
	4097	{
[123]	4098	if (arc = DosQueryProcAddr(*phmod,
	4099	0, // ordinal, ignored
	4100	(PSZ)paResolves[ul].pcszFunctionName,
	4101	paResolves[ul].ppFuncAddress))
	4102	// error:
[17]	4103	break;
	4104	}
[123]	4105
	4106	if (arc)
	4107	// V0.9.16 (2001-12-08) [umoeller]
	4108	DosFreeModule(*phmod);
[17]	4109	}
	4110
[167]	4111	return arc;
[17]	4112	}
	4113
	4114	/*
[14]	4115	*@@category: Helpers\Control program helpers\Performance (CPU load) helpers
[21]	4116	* helpers around DosPerfSysCall.
[14]	4117	*/
	4118
	4119	/* ******************************************************************
	4120	*
	4121	* Performance Counters (CPU Load)
	4122	*
	4123	********************************************************************/
	4124
	4125	/*
	4126	*@@ doshPerfOpen:
	4127	* initializes the OS/2 DosPerfSysCall API for
	4128	* the calling thread.
	4129	*
	4130	* Note: This API is not supported on all OS/2
	4131	* versions. I believe it came up with some Warp 4
	4132	* fixpak. The API is resolved dynamically by
[129]	4133	* this function (using DosQueryProcAddr).
[14]	4134	*
	4135	* This properly initializes the internal counters
	4136	* which the OS/2 kernel uses for this API. Apparently,
	4137	* with newer kernels (FP13/14), IBM has chosen to no
	4138	* longer do this automatically, which is the reason
	4139	* why many "pulse" utilities display garbage with these
	4140	* fixpaks.
	4141	*
	4142	* After NO_ERROR is returned, DOSHPERFSYS.cProcessors
	4143	* contains the no. of processors found on the system.
	4144	* All pointers in DOSHPERFSYS then point to arrays
	4145	* which have exactly cProcessors array items.
	4146	*
[129]	4147	* So after NO_ERROR was returned here, you can keep
	4148	* calling doshPerfGet to get a current snapshot of the
	4149	* IRQ and user loads for each CPU. Note that interrupts
	4150	* are only processed on CPU 0 on SMP systems.
	4151	*
[14]	4152	* Call doshPerfClose to clean up resources allocated
	4153	* by this function.
	4154	*
[129]	4155	* For more sample code, take a look at the "Pulse" widget
	4156	* in the XWorkplace sources (src\xcenter\w_pulse.c).
	4157	*
[14]	4158	* Example code:
	4159	*
	4160	+ PDOSHPERFSYS pPerf = NULL;
[129]	4161	+ APIRET arc;
[240]	4162	+ if (!(arc = doshPerfOpen(&pPerf)))
[14]	4163	+ {
[129]	4164	+ // this should really be in a timer,
	4165	+ // e.g. once per second
[14]	4166	+ ULONG ulCPU;
[129]	4167	+ if (!(arc = doshPerfGet(&pPerf)))
[14]	4168	+ {
[129]	4169	+ // go thru all CPUs
	4170	+ for (ulCPU = 0; ulCPU < pPerf->cProcessors; ulCPU++)
	4171	+ {
	4172	+ LONG lUserLoadThis = pPerf->palLoads[ulCPU];
	4173	+ ...
	4174	+ }
[14]	4175	+ }
	4176	+
	4177	+ // clean up
	4178	+ doshPerfClose(&pPerf);
	4179	+ }
	4180	+
	4181	*
	4182	*@@added V0.9.7 (2000-12-02) [umoeller]
[48]	4183	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
[14]	4184	*/
	4185
	4186	APIRET doshPerfOpen(PDOSHPERFSYS *ppPerfSys) // out: new DOSHPERFSYS structure
	4187	{
	4188	APIRET arc = NO_ERROR;
	4189
	4190	// allocate DOSHPERFSYS structure
[240]	4191	if (!(*ppPerfSys = (PDOSHPERFSYS)malloc(sizeof(DOSHPERFSYS))))
[14]	4192	arc = ERROR_NOT_ENOUGH_MEMORY;
	4193	else
	4194	{
	4195	// initialize structure
	4196	PDOSHPERFSYS pPerfSys = *ppPerfSys;
	4197	memset(pPerfSys, 0, sizeof(*pPerfSys));
	4198
	4199	// resolve DosPerfSysCall API entry
[217]	4200	if (!(arc = DosLoadModule(NULL,
	4201	0,
	4202	"DOSCALLS",
	4203	&pPerfSys->hmod)))
[14]	4204	{
[108]	4205	if (!(arc = DosQueryProcAddr(pPerfSys->hmod,
	4206	976,
	4207	"DosPerfSysCall",
[217]	4208	(PFN*)&pPerfSys->pDosPerfSysCall)))
[14]	4209	{
	4210	// OK, we got the API: initialize!
[217]	4211	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_ENABLE,
	4212	0,
	4213	0,
	4214	0)))
[14]	4215	{
	4216	pPerfSys->fInitialized = TRUE;
	4217	// call CMD_KI_DISABLE later
	4218
[108]	4219	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_PERF_INFO,
	4220	0,
[217]	4221	(ULONG)&pPerfSys->cProcessors,
[108]	4222	0)))
[14]	4223	{
[108]	4224	ULONG ul = 0,
	4225	cProcs = pPerfSys->cProcessors,
	4226	cbDouble = cProcs * sizeof(double),
	4227	cbLong = cProcs * sizeof(LONG);
[14]	4228
	4229	// allocate arrays
[108]	4230	if ( (!(pPerfSys->paCPUUtils = (PCPUUTIL)calloc(cProcs,
	4231	sizeof(CPUUTIL))))
	4232	\|\| (!(pPerfSys->padBusyPrev
	4233	= (double*)malloc(cbDouble)))
	4234	\|\| (!(pPerfSys->padTimePrev
	4235	= (double*)malloc(cbDouble)))
	4236	\|\| (!(pPerfSys->padIntrPrev
	4237	= (double*)malloc(cbDouble)))
	4238	\|\| (!(pPerfSys->palLoads
	4239	= (PLONG)malloc(cbLong)))
	4240	\|\| (!(pPerfSys->palIntrs
	4241	= (PLONG)malloc(cbLong)))
	4242	)
[14]	4243	arc = ERROR_NOT_ENOUGH_MEMORY;
	4244	else
	4245	{
[108]	4246	for (ul = 0; ul < cProcs; ul++)
[14]	4247	{
[108]	4248	pPerfSys->padBusyPrev[ul] = 0.0;
	4249	pPerfSys->padTimePrev[ul] = 0.0;
	4250	pPerfSys->padIntrPrev[ul] = 0.0;
	4251	pPerfSys->palLoads[ul] = 0;
	4252	pPerfSys->palIntrs[ul] = 0;
[14]	4253	}
	4254	}
	4255	}
	4256	}
	4257	} // end if (arc == NO_ERROR)
	4258	} // end if (arc == NO_ERROR)
	4259
[108]	4260	if (arc)
	4261	// error: clean up
[14]	4262	doshPerfClose(ppPerfSys);
[108]	4263
[14]	4264	} // end else if (!*ppPerfSys)
	4265
[167]	4266	return arc;
[14]	4267	}
	4268
	4269	/*
	4270	*@@ doshPerfGet:
	4271	* calculates a current snapshot of the system load,
	4272	* compared with the load which was calculated on
	4273	* the previous call.
	4274	*
	4275	* If you want to continually measure the system CPU
	4276	* load, this is the function you will want to call
	4277	* regularly -- e.g. with a timer once per second.
	4278	*
	4279	* Call this ONLY if doshPerfOpen returned NO_ERROR,
	4280	* or you'll get crashes.
	4281	*
[51]	4282	* If this call returns NO_ERROR, you get LONG load
	4283	* values for each CPU in the system in the arrays
	4284	* in DOSHPERFSYS (in per-mille, 0-1000).
[14]	4285	*
[51]	4286	* There are two arrays:
	4287	*
	4288	* -- DOSHPERFSYS.palLoads contains the "user" load
	4289	* for each CPU.
	4290	*
	4291	* -- DOSHPERFSYS.palIntrs contains the "IRQ" load
	4292	* for each CPU.
	4293	*
	4294	* Sum up the two values to get the total load for
	4295	* each CPU.
	4296	*
[14]	4297	* For example, if there are two CPUs, after this call,
	4298	*
[51]	4299	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
	4300	* of the first CPU,
[14]	4301	*
[51]	4302	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
	4303	* of the second CPU.
[14]	4304	*
	4305	* See doshPerfOpen for example code.
	4306	*
	4307	*@@added V0.9.7 (2000-12-02) [umoeller]
[48]	4308	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
[14]	4309	*/
	4310
	4311	APIRET doshPerfGet(PDOSHPERFSYS pPerfSys)
	4312	{
	4313	APIRET arc = NO_ERROR;
	4314	if (!pPerfSys->pDosPerfSysCall)
	4315	arc = ERROR_INVALID_PARAMETER;
	4316	else
	4317	{
[108]	4318	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_RDCNT,
	4319	(ULONG)pPerfSys->paCPUUtils,
	4320	0, 0)))
[14]	4321	{
	4322	// go thru all processors
	4323	ULONG ul = 0;
	4324	for (; ul < pPerfSys->cProcessors; ul++)
	4325	{
	4326	PCPUUTIL pCPUUtilThis = &pPerfSys->paCPUUtils[ul];
	4327
	4328	double dTime = LL2F(pCPUUtilThis->ulTimeHigh,
	4329	pCPUUtilThis->ulTimeLow);
	4330	double dBusy = LL2F(pCPUUtilThis->ulBusyHigh,
	4331	pCPUUtilThis->ulBusyLow);
[48]	4332	double dIntr = LL2F(pCPUUtilThis->ulIntrHigh,
	4333	pCPUUtilThis->ulIntrLow);
[14]	4334
	4335	double *pdBusyPrevThis = &pPerfSys->padBusyPrev[ul];
	4336	double *pdTimePrevThis = &pPerfSys->padTimePrev[ul];
[48]	4337	double *pdIntrPrevThis = &pPerfSys->padIntrPrev[ul];
[14]	4338
	4339	// avoid division by zero
[129]	4340	double dTimeDelta;
	4341	if (dTimeDelta = (dTime - *pdTimePrevThis))
[48]	4342	{
[14]	4343	pPerfSys->palLoads[ul]
	4344	= (LONG)( (double)( (dBusy - *pdBusyPrevThis)
	4345	/ dTimeDelta
	4346	* 1000.0
	4347	)
	4348	);
[48]	4349	pPerfSys->palIntrs[ul]
	4350	= (LONG)( (double)( (dIntr - *pdIntrPrevThis)
	4351	/ dTimeDelta
	4352	* 1000.0
	4353	)
	4354	);
	4355	}
[14]	4356	else
[48]	4357	{
	4358	// no clear readings are available
[14]	4359	pPerfSys->palLoads[ul] = 0;
[48]	4360	pPerfSys->palIntrs[ul] = 0;
	4361	}
[14]	4362
	4363	*pdTimePrevThis = dTime;
	4364	*pdBusyPrevThis = dBusy;
[48]	4365	*pdIntrPrevThis = dIntr;
[14]	4366	}
	4367	}
	4368	}
	4369
[167]	4370	return arc;
[14]	4371	}
	4372
	4373	/*
	4374	*@@ doshPerfClose:
	4375	* frees all resources allocated by doshPerfOpen.
	4376	*
	4377	*@@added V0.9.7 (2000-12-02) [umoeller]
[38]	4378	*@@changed V0.9.9 (2001-02-06) [umoeller]: removed disable; this broke the WarpCenter
[48]	4379	*@@changed V0.9.9 (2001-03-14) [umoeller]: fixed memory leak
	4380	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
[14]	4381	*/
	4382
	4383	APIRET doshPerfClose(PDOSHPERFSYS *ppPerfSys)
	4384	{
	4385	APIRET arc = NO_ERROR;
[129]	4386	PDOSHPERFSYS pPerfSys;
	4387	if ( (!ppPerfSys)
	4388	\|\| (!(pPerfSys = *ppPerfSys))
	4389	)
[14]	4390	arc = ERROR_INVALID_PARAMETER;
	4391	else
	4392	{
[51]	4393	// do not call this, this messes up the WarpCenter V0.9.9 (2001-02-06) [umoeller]
	4394	// if (pPerfSys->fInitialized) pPerfSys->pDosPerfSysCall(CMD_KI_DISABLE, 0, 0, 0);
[14]	4395
	4396	if (pPerfSys->paCPUUtils)
	4397	free(pPerfSys->paCPUUtils);
	4398	if (pPerfSys->padBusyPrev)
	4399	free(pPerfSys->padBusyPrev);
	4400	if (pPerfSys->padTimePrev)
	4401	free(pPerfSys->padTimePrev);
[48]	4402	if (pPerfSys->padIntrPrev)
	4403	free(pPerfSys->padIntrPrev);
	4404	if (pPerfSys->palLoads) // was missing V0.9.9 (2001-03-14) [umoeller]
	4405	free(pPerfSys->palLoads);
	4406	if (pPerfSys->palIntrs)
	4407	free(pPerfSys->palIntrs);
[14]	4408
	4409	if (pPerfSys->hmod)
	4410	DosFreeModule(pPerfSys->hmod);
	4411	free(pPerfSys);
	4412	*ppPerfSys = NULL;
	4413	}
	4414
[167]	4415	return arc;
[14]	4416	}
	4417
	4418	/*
[8]	4419	*@@category: Helpers\Control program helpers\Process management
[21]	4420	* helpers for starting subprocesses.
[8]	4421	*/
	4422
	4423	/* ******************************************************************
[14]	4424	*
	4425	* Process helpers
	4426	*
[8]	4427	********************************************************************/
	4428
[226]	4429	STATIC PVOID G_pvLocalInfoSeg = NULL;
[54]	4430
	4431	USHORT _Far16 _Pascal Dos16GetInfoSeg(PSEL pselGlobal,
	4432	PSEL pselLocal);
	4433
[8]	4434	/*
[54]	4435	* GetInfoSegs:
	4436	*
	4437	*/
	4438
[222]	4439	STATIC VOID GetInfoSegs(VOID)
[54]	4440	{
	4441	SEL GlobalInfoSegSelector,
	4442	LocalInfoSegSelector;
	4443
	4444	// get selectors (old 16-bit API; this gets called only once)
	4445	Dos16GetInfoSeg(&GlobalInfoSegSelector,
	4446	&LocalInfoSegSelector);
	4447	// thunk
[91]	4448	/* G_pvGlobalInfoSeg = (PVOID)( (GlobalInfoSegSelector << 0x000D)
	4449	& 0x01fff0000); */
[54]	4450	G_pvLocalInfoSeg = (PVOID)( (LocalInfoSegSelector << 0x000D)
	4451	& 0x01fff0000);
	4452	}
	4453
	4454	/*
	4455	*@@ doshMyPID:
	4456	* returns the PID of the current process.
	4457	*
	4458	* This uses an interesting hack which is way
	4459	* faster than DosGetInfoBlocks.
	4460	*
	4461	*@@added V0.9.9 (2001-04-04) [umoeller]
	4462	*/
	4463
	4464	ULONG doshMyPID(VOID)
	4465	{
	4466	if (!G_pvLocalInfoSeg)
	4467	// first call:
	4468	GetInfoSegs();
	4469
	4470	// PID is at offset 0 in the local info seg
[238]	4471	return *(PUSHORT)G_pvLocalInfoSeg;
[54]	4472	}
	4473
	4474	/*
[257]	4475	*@@ doshMyParentPID:
	4476	* returns the PID of the parent of the current process.
	4477	*
	4478	* This uses an interesting hack which is way
	4479	* faster than DosGetInfoBlocks.
	4480	*
	4481	*@@added V1.0.2 (2003-11-13) [umoeller]
	4482	*/
	4483
	4484	ULONG doshMyParentPID(VOID)
	4485	{
	4486	if (!G_pvLocalInfoSeg)
	4487	// first call:
	4488	GetInfoSegs();
	4489
	4490	// parent PID is at offset 2 in the local info seg
	4491	return *(PUSHORT)((PBYTE)G_pvLocalInfoSeg + 2);
	4492	}
	4493
	4494	/*
[54]	4495	*@@ doshMyTID:
	4496	* returns the TID of the current thread.
	4497	*
	4498	* This uses an interesting hack which is way
	4499	* faster than DosGetInfoBlocks.
	4500	*
	4501	*@@added V0.9.9 (2001-04-04) [umoeller]
	4502	*/
	4503
	4504	ULONG doshMyTID(VOID)
	4505	{
	4506	if (!G_pvLocalInfoSeg)
	4507	// first call:
	4508	GetInfoSegs();
	4509
	4510	// TID is at offset 6 in the local info seg
[238]	4511	return *(PUSHORT)((PBYTE)G_pvLocalInfoSeg + 6);
[54]	4512	}
	4513
	4514	/*
[8]	4515	*@@ doshExecVIO:
	4516	* executes cmd.exe with the /c parameter
	4517	* and pcszExecWithArgs. This is equivalent
	4518	* to the C library system() function,
	4519	* except that an OS/2 error code is returned
	4520	* and that this works with the VAC subsystem
	4521	* library.
	4522	*
	4523	* This uses DosExecPgm and handles the sick
	4524	* argument passing.
	4525	*
	4526	* If NO_ERROR is returned, *plExitCode receives
	4527	* the exit code of the process. If the process
	4528	* was terminated abnormally, *plExitCode receives:
	4529	*
	4530	* -- -1: hard error halt
	4531	* -- -2: 16-bit trap
	4532	* -- -3: DosKillProcess
	4533	* -- -4: 32-bit exception
	4534	*
	4535	*@@added V0.9.4 (2000-07-27) [umoeller]
	4536	*/
	4537
[116]	4538	APIRET doshExecVIO(PCSZ pcszExecWithArgs,
[8]	4539	PLONG plExitCode) // out: exit code (ptr can be NULL)
	4540	{
	4541	APIRET arc = NO_ERROR;
	4542
	4543	if (strlen(pcszExecWithArgs) > 255)
	4544	arc = ERROR_INSUFFICIENT_BUFFER;
[73]	4545	else
[8]	4546	{
	4547	CHAR szObj[CCHMAXPATH];
	4548	RESULTCODES res = {0};
	4549	CHAR szBuffer[300];
	4550
	4551	// DosExecPgm expects two args in szBuffer:
	4552	// -- cmd.exe\0
	4553	// -- then the actual argument, terminated by two 0 bytes.
	4554	memset(szBuffer, 0, sizeof(szBuffer));
	4555	strcpy(szBuffer, "cmd.exe\0");
	4556	sprintf(szBuffer + 8, "/c %s",
	4557	pcszExecWithArgs);
	4558
	4559	arc = DosExecPgm(szObj, sizeof(szObj),
	4560	EXEC_SYNC,
	4561	szBuffer,
	4562	0,
	4563	&res,
	4564	"cmd.exe");
	4565	if ((arc == NO_ERROR) && (plExitCode))
	4566	{
	4567	if (res.codeTerminate == 0)
	4568	// normal exit:
	4569	*plExitCode = res.codeResult;
	4570	else
	4571	*plExitCode = -((LONG)res.codeTerminate);
	4572	}
	4573	}
	4574
[167]	4575	return arc;
[8]	4576	}
	4577
	4578	/*
	4579	*@@ doshQuickStartSession:
	4580	* this is a shortcut to DosStartSession w/out having to
	4581	* deal with all the messy parameters.
	4582	*
	4583	* This one starts pszPath as a child session and passes
	4584	* pszParams to it.
	4585	*
	4586	* In usPgmCtl, OR any or none of the following (V0.9.0):
	4587	* -- SSF_CONTROL_NOAUTOCLOSE (0x0008): do not close automatically.
	4588	* This bit is used only for VIO Windowable apps and ignored
	4589	* for all other applications.
	4590	* -- SSF_CONTROL_MINIMIZE (0x0004)
	4591	* -- SSF_CONTROL_MAXIMIZE (0x0002)
	4592	* -- SSF_CONTROL_INVISIBLE (0x0001)
	4593	* -- SSF_CONTROL_VISIBLE (0x0000)
	4594	*
	4595	* Specifying 0 will therefore auto-close the session and make it
	4596	* visible.
	4597	*
	4598	* If (fWait), this function will create a termination queue
[94]	4599	* and not return until the child session has ended. Be warned,
	4600	* this blocks the calling thread.
[8]	4601	*
[94]	4602	* Otherwise the function will return immediately.
	4603	*
	4604	* The session and process IDs of the child session will be
	4605	* written to pulSID and ppid. Of course, in "wait" mode,
	4606	* these are no longer valid after this function returns.
	4607	*
[8]	4608	* Returns the error code of DosStartSession.
	4609	*
	4610	* Note: According to CPREF, calling DosStartSession calls
	4611	* DosExecPgm in turn for all full-screen, VIO, and PM sessions.
	4612	*
	4613	*@@changed V0.9.0 [umoeller]: prototype changed to include usPgmCtl
	4614	*@@changed V0.9.1 (99-12-30) [umoeller]: queue was sometimes not closed. Fixed.
	4615	*@@changed V0.9.3 (2000-05-03) [umoeller]: added fForeground
[94]	4616	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed potential queue leak
	4617	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed memory leak in wait mode; added pusReturn to prototype
[253]	4618	*@@changed V1.0.2 (2003-02-04) [jsmall ]: inserted new 3rd parameter for session type
	4619	*@@changed V1.0.2 (2003-02-04) [jsmall ]: changed code so when fWait = FALSE then session is started as independent, not as a child
[310]	4620	*@@changed V1.0.5 (2006-04-01) [pr]: Added pcszTitle parameter
[8]	4621	*/
	4622
[253]	4623	APIRET doshQuickStartSession(PCSZ pcszPath, // in: program to start
	4624	PCSZ pcszParams, // in: parameters for program
[310]	4625	PCSZ pcszTitle, // in: window title
[253]	4626	USHORT usSessionType, // in: session type
	4627	BOOL fForeground, // in: if TRUE, session will be in foreground
	4628	USHORT usPgmCtl, // in: STARTDATA.PgmControl
	4629	BOOL fWait, // in: wait for termination?
	4630	PULONG pulSID, // out: session ID (req.)
	4631	PPID ppid, // out: process ID (req.)
	4632	PUSHORT pusReturn) // out: in wait mode, session's return code (ptr can be NULL)
[8]	4633	{
[94]	4634	APIRET arc = NO_ERROR;
[8]	4635	// queue stuff
[52]	4636	const char *pcszQueueName = "\\queues\\xwphlpsw.que";
[8]	4637	HQUEUE hq = 0;
	4638	PID qpid = 0;
	4639
	4640	if (fWait)
	4641	{
[94]	4642	if (!(arc = DosCreateQueue(&hq,
	4643	QUE_FIFO \| QUE_CONVERT_ADDRESS,
	4644	(PSZ)pcszQueueName)))
	4645	arc = DosOpenQueue(&qpid, &hq, (PSZ)pcszQueueName);
[8]	4646	}
	4647
[94]	4648	if (!arc) // V0.9.14 (2001-08-03) [umoeller]
	4649	{
	4650	STARTDATA SData;
	4651	CHAR szObjBuf[CCHMAXPATH];
[8]	4652
[94]	4653	SData.Length = sizeof(STARTDATA);
[253]	4654	// SData.Related = SSF_RELATED_CHILD; //INDEPENDENT;
	4655	SData.Related = (fWait) ? SSF_RELATED_CHILD : SSF_RELATED_INDEPENDENT;
	4656	// V1.0.2 (2003-02-04) [jsmall]
[94]	4657	SData.FgBg = (fForeground) ? SSF_FGBG_FORE : SSF_FGBG_BACK;
	4658	// V0.9.3 (2000-05-03) [umoeller]
	4659	SData.TraceOpt = SSF_TRACEOPT_NONE;
[8]	4660
[310]	4661	// V1.0.5 (2006-04-01) [pr]
	4662	if (pcszTitle && *pcszTitle)
	4663	SData.PgmTitle = (PSZ)pcszTitle; // title for window
	4664	else
	4665	SData.PgmTitle = (PSZ)pcszPath;
	4666
[94]	4667	SData.PgmName = (PSZ)pcszPath;
	4668	SData.PgmInputs = (PSZ)pcszParams;
[8]	4669
[94]	4670	SData.TermQ = (fWait) ? (PSZ)pcszQueueName : NULL;
	4671	SData.Environment = 0;
	4672	SData.InheritOpt = SSF_INHERTOPT_PARENT;
[253]	4673	// SData.SessionType = SSF_TYPE_DEFAULT;
	4674	SData.SessionType = usSessionType; // V1.0.2 (2003-02-04) [jsmall]
[94]	4675	SData.IconFile = 0;
	4676	SData.PgmHandle = 0;
[8]	4677
[94]	4678	SData.PgmControl = usPgmCtl;
[8]	4679
[94]	4680	SData.InitXPos = 30;
	4681	SData.InitYPos = 40;
	4682	SData.InitXSize = 200;
	4683	SData.InitYSize = 140;
	4684	SData.Reserved = 0;
	4685	SData.ObjectBuffer = szObjBuf;
	4686	SData.ObjectBuffLen = (ULONG)sizeof(szObjBuf);
[8]	4687
[94]	4688	if ( (!(arc = DosStartSession(&SData, pulSID, ppid)))
	4689	&& (fWait)
	4690	)
[8]	4691	{
[94]	4692	// block on the termination queue, which is written
	4693	// to when the subprocess ends
[8]	4694	REQUESTDATA rqdata;
[94]	4695	ULONG cbData = 0;
	4696	PULONG pulData = NULL;
[8]	4697	BYTE elpri;
	4698
	4699	rqdata.pid = qpid;
[94]	4700	if (!(arc = DosReadQueue(hq, // in: queue handle
	4701	&rqdata, // out: pid and ulData
	4702	&cbData, // out: size of data returned
	4703	(PVOID*)&pulData, // out: data returned
	4704	0, // in: remove first element in queue
	4705	0, // in: wait for queue data (block thread)
	4706	&elpri, // out: element's priority
	4707	0))) // in: event semaphore to be posted
	4708	{
	4709	if (!rqdata.ulData)
	4710	{
	4711	// child session ended:
	4712	// V0.9.14 (2001-08-03) [umoeller]
	4713
	4714	// pulSID = (pulData) & 0xffff;
	4715	if (pusReturn)
	4716	pusReturn = ((pulData) >> 16) & 0xffff;
	4717
	4718	}
	4719	// else: continue looping
	4720
	4721	if (pulData)
	4722	DosFreeMem(pulData);
	4723	}
[8]	4724	}
	4725	}
	4726
	4727	if (hq)
	4728	DosCloseQueue(hq);
	4729
[167]	4730	return arc;
[8]	4731	}
	4732
	4733

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/helpers/dosh.c

Download in other formats: