Context Navigation

source: trunk/src/helpers/dosh.c@ 130

Visit:

Last change on this file since 130 was 129, checked in by umoeller, 24 years ago
Executable updates, mostly.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 115.3 KB

Line
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	/*
32	* This file Copyright (C) 1997-2000 Ulrich Mller.
33	* This file is part of the "XWorkplace helpers" source package.
34	* This is free software; you can redistribute it and/or modify
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
49	#define INCL_DOSMODULEMGR
50	#define INCL_DOSPROCESS
51	#define INCL_DOSSESMGR
52	#define INCL_DOSQUEUES
53	#define INCL_DOSSEMAPHORES
54	#define INCL_DOSMISC
55	#define INCL_DOSDEVICES
56	#define INCL_DOSDEVIOCTL
57	#define INCL_DOSERRORS
58
59	#define INCL_KBD
60	#include <os2.h>
61
62	#include <stdlib.h>
63	#include <string.h>
64	#include <stdio.h>
65	#include <stdarg.h>
66	#include <ctype.h>
67
68	#include "setup.h" // code generation and debugging options
69
70	#include "helpers\dosh.h"
71	#include "helpers\standards.h"
72
73	#pragma hdrstop
74
75	// static const CHAR G_acDriveLetters[28] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
76
77	/*
78	*@@category: Helpers\Control program helpers\Miscellaneous
79	* Miscellaneous helpers in dosh.c that didn't fit into any other
80	* category.
81	*/
82
83	/* ******************************************************************
84	*
85	* Miscellaneous
86	*
87	********************************************************************/
88
89	/*
90	*@@ doshGetChar:
91	* reads a single character from the keyboard.
92	* Useful for VIO sessions, since there's great
93	* confusion between the various C dialects about
94	* how to use getc(), and getc() doesn't work
95	* with the VAC subsystem library.
96	*
97	*@@added V0.9.4 (2000-07-27) [umoeller]
98	*/
99
100	CHAR doshGetChar(VOID)
101	{
102	// CHAR c;
103	// ULONG ulRead = 0;
104
105	KBDKEYINFO kki;
106	KbdCharIn(&kki,
107	0, // wait
108	0);
109
110	return (kki.chChar);
111	}
112
113	/*
114	*@@ doshQueryShiftState:
115	* returns TRUE if any of the SHIFT keys are
116	* currently pressed. Useful for checks during
117	* WM_COMMAND messages from menus.
118	*
119	*@@changed V0.9.5 (2000-09-27) [umoeller]: added error checking
120	*/
121
122	BOOL doshQueryShiftState(VOID)
123	{
124	BOOL brc = FALSE;
125	APIRET arc = NO_ERROR;
126	HFILE hfKbd;
127	ULONG ulAction;
128
129	if (!(arc = DosOpen("KBD$", &hfKbd, &ulAction, 0,
130	FILE_NORMAL,
131	FILE_OPEN,
132	OPEN_ACCESS_READONLY \| OPEN_SHARE_DENYWRITE,
133	(PEAOP2)NULL)))
134	{
135	SHIFTSTATE ShiftState;
136	ULONG cbDataLen = sizeof(ShiftState);
137
138	if (!(arc = DosDevIOCtl(hfKbd, IOCTL_KEYBOARD, KBD_GETSHIFTSTATE,
139	NULL, 0, NULL, // no parameters
140	&ShiftState, cbDataLen, &cbDataLen)))
141	brc = ((ShiftState.fsState & 3) != 0);
142
143	DosClose(hfKbd);
144	}
145
146	return brc;
147	}
148
149	/*
150	*@@ doshIsWarp4:
151	* checks the OS/2 system version number.
152	*
153	* Returns:
154	*
155	* -- 0 (FALSE): OS/2 2.x or Warp 3 is running.
156	*
157	* -- 1: Warp 4.0 is running.
158	*
159	* -- 2: Warp 4.5 is running (WSeB or Warp 4 FP 13+ or eCS
160	* or ACP/MCP), or even something newer.
161	*
162	*@@changed V0.9.2 (2000-03-05) [umoeller]: reported TRUE on Warp 3 also; fixed
163	*@@changed V0.9.6 (2000-10-16) [umoeller]: patched for speed
164	*@@changed V0.9.9 (2001-04-04) [umoeller]: now returning 2 for Warp 4.5 and above
165	*/
166
167	ULONG doshIsWarp4(VOID)
168	{
169	static BOOL s_fQueried = FALSE;
170	static ULONG s_ulrc = 0;
171
172	if (!s_fQueried)
173	{
174	// first call:
175	ULONG aulBuf[3];
176
177	DosQuerySysInfo(QSV_VERSION_MAJOR, // 11
178	QSV_VERSION_MINOR, // 12
179	&aulBuf, sizeof(aulBuf));
180	// Warp 3 is reported as 20.30
181	// Warp 4 is reported as 20.40
182	// Aurora is reported as 20.45
183
184	if ( (aulBuf[0] > 20) // major > 20; not the case with Warp 3, 4, 5
185	\|\| ( (aulBuf[0] == 20) // major == 20 and minor >= 45
186	&& (aulBuf[1] >= 45)
187	)
188	)
189	// Warp 4.5 or newer:
190	s_ulrc = 2;
191	else if ( (aulBuf[0] == 20) // major == 20 and minor == 40
192	&& (aulBuf[1] == 40)
193	)
194	// Warp 4:
195	s_ulrc = 1;
196
197	s_fQueried = TRUE;
198	}
199
200	return (s_ulrc);
201	}
202
203	/*
204	*@@ doshQuerySysErrorMsg:
205	* this retrieves the error message for a system error
206	* (APIRET) from the system error message file (OSO001.MSG).
207	* This file better be on the DPATH (it normally is).
208	*
209	* This returns the string in the "SYSxxx: blahblah" style,
210	* which is normally displayed on the command line when
211	* errors occur.
212	*
213	* The error message is returned in a newly allocated
214	* buffer, which should be free()'d afterwards.
215	*
216	* Returns NULL upon errors.
217	*/
218
219	PSZ doshQuerySysErrorMsg(APIRET arc) // in: DOS error code
220	{
221	PSZ pszReturn = 0;
222	CHAR szDosError[1000];
223	ULONG cbDosError = 0;
224	DosGetMessage(NULL, 0, // no string replacements
225	szDosError, sizeof(szDosError),
226	arc,
227	"OSO001.MSG", // default OS/2 message file
228	&cbDosError);
229	if (cbDosError > 2)
230	{
231	szDosError[cbDosError - 2] = 0;
232	pszReturn = strdup(szDosError);
233	}
234	return (pszReturn);
235	}
236
237	/*
238	*@@ doshQuerySysUptime:
239	* returns the system uptime in milliseconds.
240	* This can be used for time comparisons.
241	*
242	*@@added V0.9.12 (2001-05-18) [umoeller]
243	*/
244
245	ULONG doshQuerySysUptime(VOID)
246	{
247	ULONG ulms;
248	DosQuerySysInfo(QSV_MS_COUNT,
249	QSV_MS_COUNT,
250	&ulms,
251	sizeof(ulms));
252	return (ulms);
253	}
254
255	/*
256	*@@ doshDevIOCtl:
257	*
258	* Works with those IOCtls where the buffer
259	* size parameters are always the same anyway,
260	* which applies to all IOCtls I have seen
261	* so far.
262	*
263	*@@added V0.9.13 (2001-06-14) [umoeller]
264	*/
265
266	APIRET doshDevIOCtl(HFILE hf,
267	ULONG ulCategory,
268	ULONG ulFunction,
269	PVOID pvParams,
270	ULONG cbParams,
271	PVOID pvData,
272	ULONG cbData)
273	{
274	return (DosDevIOCtl(hf,
275	ulCategory,
276	ulFunction,
277	pvParams, cbParams, &cbParams,
278	pvData, cbData, &cbData));
279	}
280
281	/*
282	*@@category: Helpers\Control program helpers\Shared memory management
283	* helpers for allocating and requesting shared memory.
284	*/
285
286	/* ******************************************************************
287	*
288	* Memory helpers
289	*
290	********************************************************************/
291
292	/*
293	*@@ Allocate:
294	* wrapper around malloc() which automatically
295	* sets ERROR_NOT_ENOUGH_MEMORY.
296	*
297	*@@added V0.9.16 (2001-10-19) [umoeller]
298	*/
299
300	PVOID doshMalloc(ULONG cb,
301	APIRET *parc)
302	{
303	PVOID pv;
304	*parc = NO_ERROR;
305	if (!(pv = malloc(cb)))
306	*parc = ERROR_NOT_ENOUGH_MEMORY;
307
308	return (pv);
309	}
310
311	/*
312	*@@ doshAllocArray:
313	* allocates c * cbArrayItem bytes.
314	* Similar to calloc(), but returns
315	* error codes:
316	*
317	* -- NO_ERROR: ppv and pcbAllocated were set.
318	*
319	* -- ERROR_NO_DATA: either c or cbArrayItem are
320	* zero.
321	*
322	* -- ERROR_NOT_ENOUGH_MEMORY: malloc() failed.
323	*
324	*@@added V0.9.16 (2001-12-08) [umoeller]
325	*/
326
327	APIRET doshAllocArray(ULONG c, // in: array item count
328	ULONG cbArrayItem, // in: size of one array item
329	PBYTE *ppv, // out: memory ptr if NO_ERROR is returned
330	PULONG pcbAllocated) // out: # of bytes allocated
331	{
332	if (!c \|\| !cbArrayItem)
333	return ERROR_NO_DATA;
334
335	pcbAllocated = c cbArrayItem;
336	if (!(ppv = (PBYTE)malloc(pcbAllocated)))
337	return ERROR_NOT_ENOUGH_MEMORY;
338
339	return NO_ERROR;
340	}
341
342	/*
343	*@@ doshAllocSharedMem:
344	* wrapper for DosAllocSharedMem which has
345	* a malloc()-like syntax. Just due to my
346	* lazyness.
347	*
348	* Note that ulSize is always rounded up to the
349	* next 4KB value, so don't use this hundreds of times.
350	*
351	* Returns NULL upon errors. Possible errors include
352	* that a memory block calle pcszName has already been
353	* allocated.
354	*
355	* Use DosFreeMem(pvrc) to free the memory. The memory
356	* will only be freed if no other process has requested
357	* access.
358	*
359	*@@added V0.9.3 (2000-04-18) [umoeller]
360	*/
361
362	PVOID doshAllocSharedMem(ULONG ulSize, // in: requested mem block size (rounded up to 4KB)
363	const char* pcszName) // in: name of block ("\\SHAREMEM\\xxx") or NULL
364	{
365	PVOID pvrc = NULL;
366	APIRET arc = DosAllocSharedMem((PVOID*)&pvrc,
367	(PSZ)pcszName,
368	ulSize,
369	PAG_COMMIT \| PAG_READ \| PAG_WRITE);
370	if (arc == NO_ERROR)
371	return (pvrc);
372
373	return (NULL);
374	}
375
376	/*
377	*@@ doshRequestSharedMem:
378	* requests access to a block of named shared memory
379	* allocated by doshAllocSharedMem.
380	*
381	* Returns NULL upon errors.
382	*
383	* Use DosFreeMem(pvrc) to free the memory. The memory
384	* will only be freed if no other process has requested
385	* access.
386	*
387	*@@added V0.9.3 (2000-04-19) [umoeller]
388	*/
389
390	PVOID doshRequestSharedMem(PCSZ pcszName)
391	{
392	PVOID pvrc = NULL;
393	APIRET arc = DosGetNamedSharedMem((PVOID*)pvrc,
394	(PSZ)pcszName,
395	PAG_READ \| PAG_WRITE);
396	if (arc == NO_ERROR)
397	return (pvrc);
398
399	return (NULL);
400	}
401
402	/*
403	*@@category: Helpers\Control program helpers\Drive management
404	* functions for managing drives... enumerating, testing,
405	* querying etc.
406	*/
407
408	/* ******************************************************************
409	*
410	* Drive helpers
411	*
412	********************************************************************/
413
414	/*
415	*@@ doshIsFixedDisk:
416	* checks whether a disk is fixed or removeable.
417	* ulLogicalDrive must be 1 for drive A:, 2 for B:, ...
418	* The result is stored in *pfFixed.
419	* Returns DOS error code.
420	*
421	* From my testing, this function does _not_ provoke
422	* "drive not ready" popups, even if the disk is not
423	* ready.
424	*
425	* Warning: This uses DosDevIOCtl, which has proved
426	* to cause problems with some device drivers for
427	* removeable disks.
428	*
429	*@@changed V0.9.14 (2001-08-03) [umoeller]: added extra fix for A: and B:
430	*/
431
432	APIRET doshIsFixedDisk(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
433	PBOOL pfFixed) // out: TRUE for fixed disks
434	{
435	APIRET arc = ERROR_INVALID_DRIVE;
436
437	if ( (ulLogicalDrive == 1)
438	\|\| (ulLogicalDrive == 2)
439	)
440	{
441	// drive A: and B: can never be fixed V0.9.14 (2001-08-03) [umoeller]
442	*pfFixed = FALSE;
443	return NO_ERROR;
444	}
445
446	if (ulLogicalDrive)
447	{
448	// parameter packet
449	#pragma pack(1)
450	struct {
451	UCHAR command,
452	drive;
453	} parms;
454	#pragma pack()
455
456	// data packet
457	UCHAR ucNonRemoveable;
458
459	parms.drive = (UCHAR)(ulLogicalDrive-1);
460	arc = doshDevIOCtl((HFILE)-1,
461	IOCTL_DISK, // 0x08
462	DSK_BLOCKREMOVABLE, // 0x20
463	&parms, sizeof(parms),
464	&ucNonRemoveable, sizeof(ucNonRemoveable));
465
466	if (arc == NO_ERROR)
467	*pfFixed = (BOOL)ucNonRemoveable;
468	}
469
470	return (arc);
471	}
472
473	/*
474	*@@ doshQueryDiskParams:
475	* this retrieves more information about a given drive,
476	* which is stored in the specified BIOSPARAMETERBLOCK
477	* structure.
478	*
479	* BIOSPARAMETERBLOCK is defined in the Toolkit headers,
480	* and from my testing, it's the same with the Toolkits
481	* 3 and 4.5.
482	*
483	* If NO_ERROR is returned, the bDeviceType field can
484	* be one of the following (according to CPREF):
485	*
486	* -- 0: 48 TPI low-density diskette drive
487	* -- 1: 96 TPI high-density diskette drive
488	* -- 2: 3.5-inch 720KB diskette drive
489	* -- 3: 8-Inch single-density diskette drive
490	* -- 4: 8-Inch double-density diskette drive
491	* -- 5: Fixed disk
492	* -- 6: Tape drive
493	* -- 7: Other (includes 1.44MB 3.5-inch diskette drive)
494	* -- 8: R/W optical disk
495	* -- 9: 3.5-inch 4.0MB diskette drive (2.88MB formatted)
496	*
497	* From my testing, this function does _not_ provoke
498	* "drive not ready" popups, even if the disk is not
499	* ready.
500	*
501	* Warning: This uses DosDevIOCtl, which has proved
502	* to cause problems with some device drivers for
503	* removeable disks.
504	*
505	* This returns the DOS error code of DosDevIOCtl.
506	*
507	*@@added V0.9.0 [umoeller]
508	*@@changed V0.9.13 (2001-06-14) [umoeller]: changed prototype to use BIOSPARAMETERBLOCK directly
509	*@@changed V0.9.13 (2001-06-14) [umoeller]: now querying standard media, no redetermine
510	*/
511
512	APIRET doshQueryDiskParams(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
513	PBIOSPARAMETERBLOCK pdp) // out: drive parameters
514	{
515	APIRET arc = ERROR_INVALID_DRIVE;
516
517	if (ulLogicalDrive)
518	{
519	#pragma pack(1)
520	// parameter packet
521	struct {
522	UCHAR ucCommand,
523	ucDrive;
524	} parms;
525	#pragma pack()
526
527	parms.ucCommand = 0; // 0 = return standard media,
528	// 1 = read currently inserted media
529	// (1 doesn't work any more, returns arc 87
530	// V0.9.13 (2001-06-14) [umoeller])
531	parms.ucDrive=(UCHAR)(ulLogicalDrive-1);
532
533	// zero the structure V0.9.13 (2001-06-14) [umoeller]
534	memset(pdp, 0, sizeof(BIOSPARAMETERBLOCK));
535
536	arc = doshDevIOCtl((HFILE)-1,
537	IOCTL_DISK, // 0x08
538	DSK_GETDEVICEPARAMS, // 0x63
539	&parms, sizeof(parms),
540	pdp, sizeof(BIOSPARAMETERBLOCK));
541
542	/* if (!arc)
543	{
544	_Pmpf((" bDeviceType: %d", pdp->bDeviceType));
545	_Pmpf((" bytes per sector: %d", pdp->usBytesPerSector));
546	_Pmpf((" sectors per track: %d", pdp->usSectorsPerTrack));
547	} */
548	}
549
550	return (arc);
551	}
552
553	/*
554	*@@ doshIsCDROM:
555	* tests the specified BIOSPARAMETERBLOCK
556	* for whether it represents a CD-ROM drive.
557	*
558	* The BIOSPARAMETERBLOCK must be filled
559	* first using doshQueryDiskParams.
560	*
561	*@@added V0.9.13 (2001-06-14) [umoeller]
562	*/
563
564	BOOL doshIsCDROM(PBIOSPARAMETERBLOCK pdp)
565	{
566	return ( (pdp)
567	&& (pdp->bDeviceType == 7) // "other"
568	&& (pdp->usBytesPerSector == 2048)
569	&& (pdp->usSectorsPerTrack == (USHORT)-1)
570	);
571	}
572
573	/*
574	*@@ doshHasAudioCD:
575	* sets *pfAudio to whether ulLogicalDrive
576	* currently has an audio CD inserted.
577	*
578	* Better call this only if you're sure that
579	* ulLogicalDrive is a CD-ROM drive. Use
580	* doshIsCDROM to check.
581	*
582	*@@added V0.9.14 (2001-08-01) [umoeller]
583	*/
584
585	APIRET doshHasAudioCD(ULONG ulLogicalDrive,
586	HFILE hfDrive, // in: DASD open
587	BOOL fMixedModeCD,
588	PBOOL pfAudio)
589	{
590	APIRET arc = NO_ERROR;
591
592	ULONG ulAudioTracks = 0,
593	ulDataTracks = 0;
594
595	CHAR cds1[4] = { 'C', 'D', '0', '1' };
596	CHAR cds2[4];
597
598	*pfAudio = FALSE;
599
600	// check for proper driver signature
601	if (!(arc = doshDevIOCtl(hfDrive,
602	IOCTL_CDROMDISK,
603	CDROMDISK_GETDRIVER,
604	&cds1, sizeof(cds1),
605	&cds2, sizeof(cds2))))
606	{
607	if (memcmp(&cds1, &cds2, 4))
608	// this is not a CD-ROM then:
609	arc = NO_ERROR;
610	else
611	{
612	struct {
613	UCHAR ucFirstTrack,
614	ucLastTrack;
615	ULONG ulLeadOut;
616	} cdat;
617
618	// get track count
619	if (!(arc = doshDevIOCtl(hfDrive,
620	IOCTL_CDROMAUDIO,
621	CDROMAUDIO_GETAUDIODISK,
622	&cds1, sizeof(cds1),
623	&cdat, sizeof(cdat))))
624	{
625	// still no error: build the audio TOC
626	ULONG i;
627	for (i = cdat.ucFirstTrack;
628	i <= cdat.ucLastTrack;
629	i++)
630	{
631	BYTE cdtp[5] =
632	{ 'C', 'D', '0', '1', (UCHAR)i };
633
634	struct {
635	ULONG ulTrackAddress;
636	BYTE bFlags;
637	} trackdata;
638
639	if (!(arc = doshDevIOCtl(hfDrive,
640	IOCTL_CDROMAUDIO,
641	CDROMAUDIO_GETAUDIOTRACK,
642	&cdtp, sizeof(cdtp),
643	&trackdata, sizeof(trackdata))))
644	{
645	if (trackdata.bFlags & 64)
646	ulDataTracks++;
647	else
648	{
649	ulAudioTracks++;
650
651	if (!fMixedModeCD)
652	{
653	// caller doesn't want mixed mode:
654	// stop here
655	ulDataTracks = 0;
656	break;
657	}
658	}
659	}
660	}
661
662	// _Pmpf((" got %d audio, %d data tracks",
663	// ulAudioTracks, ulDataTracks));
664
665	if (!ulDataTracks)
666	*pfAudio = TRUE;
667	}
668	else
669	{
670	// not audio disk:
671	// go on then
672	// _Pmpf((" CDROMAUDIO_GETAUDIODISK returned %d", arc));
673	arc = NO_ERROR;
674	}
675	}
676	}
677	else
678	{
679	// not CD-ROM: go on then
680	// _Pmpf((" CDROMDISK_GETDRIVER returned %d", arc));
681	arc = NO_ERROR;
682	}
683
684	return (arc);
685	}
686
687	/*
688	*@@ doshEnumDrives:
689	* this function enumerates all valid drive letters on
690	* the system by composing a string of drive letters
691	* in the buffer pointed to by pszBuffer, which should
692	* be 27 characters in size to hold information for
693	* all drives. The buffer will be null-terminated.
694	*
695	* If (pcszFileSystem != NULL), only drives matching
696	* the specified file system type (e.g. "HPFS") will
697	* be enumerated. If (pcszFileSystem == NULL), all
698	* drives will be enumerated.
699	*
700	* If (fSkipRemovables == TRUE), removeable drives will
701	* be skipped. This applies to floppy, CD-ROM, and
702	* virtual floppy drives. This will start the search
703	* at drive letter C: so that drives A: and B: will
704	* never be checked (to avoid the hardware bumps).
705	*
706	* Otherwise, the search starts at drive A:. Still,
707	* removeable drives will only be added if valid media
708	* is inserted.
709	*
710	*@@changed V0.9.4 (2000-07-03) [umoeller]: this stopped at the first invalid drive letter; fixed
711	*@@changed V0.9.4 (2000-07-03) [umoeller]: added fSkipRemoveables
712	*/
713
714	VOID doshEnumDrives(PSZ pszBuffer, // out: drive letters
715	PCSZ pcszFileSystem, // in: FS's to match or NULL
716	BOOL fSkipRemoveables) // in: if TRUE, only non-removeable disks will be returned
717	{
718	CHAR szName[5] = "";
719	ULONG ulLogicalDrive = 1, // start with drive A:
720	ulFound = 0; // found drives count
721	APIRET arc = NO_ERROR; // return code
722
723	if (fSkipRemoveables)
724	// start with drive C:
725	ulLogicalDrive = 3;
726
727	// go thru the drives, start with C: (== 3), stop after Z: (== 26)
728	while (ulLogicalDrive <= 26)
729	{
730	#pragma pack(1)
731	struct
732	{
733	UCHAR dummy,drive;
734	} parms;
735	#pragma pack()
736
737	// data packet
738	UCHAR nonRemovable=0;
739
740	parms.drive=(UCHAR)(ulLogicalDrive-1);
741	arc = doshDevIOCtl((HFILE)-1,
742	IOCTL_DISK,
743	DSK_BLOCKREMOVABLE,
744	&parms, sizeof(parms),
745	&nonRemovable, sizeof(nonRemovable));
746
747	if ( // fixed disk and non-removeable
748	((arc == NO_ERROR) && (nonRemovable))
749	// or network drive:
750	\|\| (arc == ERROR_NOT_SUPPORTED)
751	)
752	{
753	ULONG ulOrdinal = 0; // ordinal of entry in name list
754	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
755	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
756	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
757
758	szName[0] = ulLogicalDrive + 'A' - 1;
759	szName[1] = ':';
760	szName[2] = '\0';
761
762	arc = DosQueryFSAttach(szName, // logical drive of attached FS
763	ulOrdinal, // ignored for FSAIL_QUERYNAME
764	FSAIL_QUERYNAME, // return data for a Drive or Device
765	pfsqBuffer, // returned data
766	&cbBuffer); // returned data length
767
768	if (arc == NO_ERROR)
769	{
770	// The data for the last three fields in the FSQBUFFER2
771	// structure are stored at the offset of fsqBuffer.szName.
772	// Each data field following fsqBuffer.szName begins
773	// immediately after the previous item.
774	CHAR* pszFSDName = (PSZ)&(pfsqBuffer->szName) + (pfsqBuffer->cbName) + 1;
775	if (pcszFileSystem == NULL)
776	{
777	// enum-all mode: always copy
778	pszBuffer[ulFound] = szName[0]; // drive letter
779	ulFound++;
780	}
781	else if (strcmp(pszFSDName, pcszFileSystem) == 0)
782	{
783	pszBuffer[ulFound] = szName[0]; // drive letter
784	ulFound++;
785	}
786	}
787	}
788
789	ulLogicalDrive++;
790	} // end while (G_acDriveLetters[ulLogicalDrive] <= 'Z')
791
792	pszBuffer[ulFound] = '\0';
793	}
794
795	/*
796	*@@ doshQueryBootDrive:
797	* returns the letter of the boot drive as a
798	* single (capital) character, which is useful for
799	* constructing file names using sprintf and such.
800	*/
801
802	CHAR doshQueryBootDrive(VOID)
803	{
804	ULONG ulBootDrive;
805	DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
806	&ulBootDrive,
807	sizeof(ulBootDrive));
808	return (ulBootDrive + 'A' - 1);
809	}
810
811	/*
812	*@@ doshAssertDrive:
813	* this checks for whether the given drive
814	* is currently available without provoking
815	* those ugly white "Drive not ready" popups.
816	*
817	* "fl" can specify additional flags for testing
818	* and can be any combination of:
819	*
820	* -- ASSERTFL_MIXEDMODECD: whether to allow
821	* mixed-mode CD-ROMs. See error codes below.
822	*
823	* This returns (from my testing):
824	*
825	* -- NO_ERROR: drive is available.
826	*
827	* -- ERROR_INVALID_DRIVE (15): drive letter does not exist.
828	*
829	* -- ERROR_NOT_READY (21): drive exists, but is not ready.
830	* This is produced by floppies and CD-ROM drives
831	* which do not have valid media inserted.
832	*
833	* -- ERROR_AUDIO_CD_ROM (10000): special error code returned
834	* only by this function if a CD-ROM drive has audio
835	* media inserted.
836	*
837	* If ASSERTFL_MIXEDMODECD was specified, ERROR_AUDIO_CD_ROM
838	* is returned _only_ if _no_ data tracks are
839	* present on a CD-ROM. Since OS/2 is not very
840	* good at handling mixed-mode CDs, this might not
841	* be desireable.
842	*
843	* If ASSERTFL_MIXEDMODECD was not set, ERROR_AUDIO_CD_ROM
844	* will be returned already if _one_ audio track is present.
845	*
846	*@@changed V0.9.1 (99-12-13) [umoeller]: rewritten, prototype changed. Now using DosOpen on the drive instead of DosError.
847	*@@changed V0.9.1 (2000-01-08) [umoeller]: DosClose was called even if DosOpen failed, which messed up OS/2 error handling.
848	*@@changed V0.9.1 (2000-02-09) [umoeller]: this didn't work for network drives, including RAMFS; fixed.
849	*@@changed V0.9.3 (2000-03-28) [umoeller]: added check for network drives, which weren't working
850	*@@changed V0.9.4 (2000-08-03) [umoeller]: more network fixes
851	*@@changed V0.9.9 (2001-03-19) [pr]: validate drive number
852	*@@changed V0.9.11 (2001-04-23) [umoeller]: added an extra check for floppies
853	*@@changed V0.9.13 (2001-06-14) [umoeller]: added "fl" parameter and lots of CD-ROM checks
854	*/
855
856	APIRET doshAssertDrive(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
857	ULONG fl) // in: ASSERTFL_* flags
858	{
859	APIRET arc = NO_ERROR;
860	BOOL fFixed = FALSE,
861	fCDROM = FALSE;
862
863	if ((ulLogicalDrive < 1) \|\| (ulLogicalDrive > 26))
864	return(ERROR_PATH_NOT_FOUND);
865
866	arc = doshIsFixedDisk(ulLogicalDrive,
867	&fFixed); // V0.9.13 (2001-06-14) [umoeller]
868
869	// _Pmpf((__FUNCTION__ ": doshIsFixedDisk returned %d for disk %d", arc, ulLogicalDrive));
870	// _Pmpf((" fFixed is %d", fFixed));
871
872	if (!arc)
873	if (!fFixed)
874	{
875	// removeable disk:
876	// check if it's a CD-ROM
877	BIOSPARAMETERBLOCK bpb;
878	arc = doshQueryDiskParams(ulLogicalDrive,
879	&bpb);
880	// _Pmpf((" doshQueryDiskParams returned %d", arc));
881
882	if ( (!arc)
883	&& (doshIsCDROM(&bpb))
884	)
885	{
886	// _Pmpf((" --> is CD-ROM"));
887	fCDROM = TRUE;
888	}
889	}
890
891	if (!arc)
892	{
893	HFILE hfDrive = NULLHANDLE;
894
895	ULONG ulTemp = 0;
896	CHAR szDrive[3] = "C:";
897	szDrive[0] = 'A' + ulLogicalDrive - 1;
898
899	arc = DosOpen(szDrive, // "C:", "D:", ...
900	&hfDrive,
901	&ulTemp,
902	0,
903	FILE_NORMAL,
904	OPEN_ACTION_FAIL_IF_NEW
905	\| OPEN_ACTION_OPEN_IF_EXISTS,
906	OPEN_FLAGS_DASD
907	\| OPEN_FLAGS_FAIL_ON_ERROR
908	\| OPEN_FLAGS_NOINHERIT // V0.9.6 (2000-11-25) [pr]
909	// \| OPEN_ACCESS_READONLY // V0.9.13 (2001-06-14) [umoeller]
910	\| OPEN_SHARE_DENYNONE,
911	NULL);
912
913	// _Pmpf((" DosOpen(OPEN_FLAGS_DASD) returned %d", arc));
914
915	// this still returns NO_ERROR for audio CDs in a
916	// CD-ROM drive...
917	// however, the WPS then attempts to read in the
918	// root directory for audio CDs, which produces
919	// a "sector not found" error box...
920
921	if ( (!arc)
922	&& (hfDrive)
923	&& (fCDROM)
924	)
925	{
926	BOOL fAudio;
927	if ( (!(arc = doshHasAudioCD(ulLogicalDrive,
928	hfDrive,
929	((fl & ASSERTFL_MIXEDMODECD) != 0),
930	&fAudio)))
931	&& (fAudio)
932	)
933	arc = ERROR_AUDIO_CD_ROM; // special private error code (10000)
934	}
935
936	if (hfDrive)
937	DosClose(hfDrive);
938	}
939
940	switch (arc)
941	{
942	case ERROR_NETWORK_ACCESS_DENIED: // 65
943	// added V0.9.3 (2000-03-27) [umoeller];
944	// according to user reports, this is returned
945	// by all network drives, which apparently don't
946	// support DASD DosOpen
947	case ERROR_ACCESS_DENIED: // 5
948	// added V0.9.4 (2000-07-10) [umoeller]
949	// LAN drives still didn't work... apparently
950	// the above only works for NFS drives
951	case ERROR_PATH_NOT_FOUND: // 3
952	// added V0.9.4 (2000-08-03) [umoeller]:
953	// this is returned by some other network types...
954	// sigh...
955	case ERROR_NOT_SUPPORTED: // 50
956	// this is returned by file systems which don't
957	// support DASD DosOpen;
958	// use some other method then, this isn't likely
959	// to fail -- V0.9.1 (2000-02-09) [umoeller]
960
961	// but don't do this for floppies
962	// V0.9.11 (2001-04-23) [umoeller]
963	if (ulLogicalDrive > 2)
964	{
965	FSALLOCATE fsa;
966	arc = DosQueryFSInfo(ulLogicalDrive,
967	FSIL_ALLOC,
968	&fsa,
969	sizeof(fsa));
970	// _Pmpf((" re-checked, DosQueryFSInfo returned %d", arc));
971	}
972	break;
973	}
974
975	return (arc);
976	}
977
978	/*
979	*@@ doshSetLogicalMap:
980	* sets the mapping of logical floppy drives onto a single
981	* physical floppy drive.
982	* This means selecting either drive A: or drive B: to refer
983	* to the physical drive.
984	*
985	*@@added V0.9.6 (2000-11-24) [pr]
986	*/
987
988	APIRET doshSetLogicalMap(ULONG ulLogicalDrive)
989	{
990	CHAR name[3] = "?:";
991	ULONG fd = 0,
992	action = 0;
993	// paramsize = 0;
994	// datasize = 0;
995	APIRET rc = NO_ERROR;
996	USHORT data,
997	param;
998
999	name[0] = doshQueryBootDrive();
1000	rc = DosOpen(name,
1001	&fd,
1002	&action,
1003	0,
1004	0,
1005	OPEN_ACTION_FAIL_IF_NEW
1006	\| OPEN_ACTION_OPEN_IF_EXISTS,
1007	OPEN_FLAGS_DASD
1008	\| OPEN_FLAGS_FAIL_ON_ERROR
1009	\| OPEN_FLAGS_NOINHERIT
1010	\| OPEN_ACCESS_READONLY
1011	\| OPEN_SHARE_DENYNONE,
1012	0);
1013
1014	if (rc == NO_ERROR)
1015	{
1016	param = 0;
1017	data = (USHORT)ulLogicalDrive;
1018	// paramsize = sizeof(param);
1019	// datasize = sizeof(data);
1020	rc = doshDevIOCtl(fd,
1021	IOCTL_DISK, DSK_SETLOGICALMAP,
1022	&param, sizeof(param),
1023	&data, sizeof(data));
1024	DosClose(fd);
1025	}
1026
1027	return(rc);
1028	}
1029
1030	/*
1031	*@@ doshQueryDiskSize:
1032	* returns the size of the specified disk in bytes.
1033	*
1034	* Note: This returns a "double" value, because a ULONG
1035	* can only hold values of some 4 billion, which would
1036	* lead to funny results for drives > 4 GB.
1037	*
1038	*@@added V0.9.11 (2001-04-18) [umoeller]
1039	*/
1040
1041	APIRET doshQueryDiskSize(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1042	double *pdSize)
1043	{
1044	APIRET arc = NO_ERROR;
1045	FSALLOCATE fsa;
1046	// double dbl = -1;
1047
1048	if (!(arc = DosQueryFSInfo(ulLogicalDrive, FSIL_ALLOC, &fsa, sizeof(fsa))))
1049	pdSize = ((double)fsa.cSectorUnit fsa.cbSector * fsa.cUnit);
1050
1051	return (arc);
1052	}
1053
1054	/*
1055	*@@ doshQueryDiskFree:
1056	* returns the number of bytes remaining on the disk
1057	* specified by the given logical drive.
1058	*
1059	* Note: This returns a "double" value, because a ULONG
1060	* can only hold values of some 4 billion, which would
1061	* lead to funny results for drives > 4 GB.
1062	*
1063	*@@changed V0.9.0 [umoeller]: fixed another > 4 GB bug (thanks to Rdiger Ihle)
1064	*@@changed V0.9.7 (2000-12-01) [umoeller]: changed prototype
1065	*/
1066
1067	APIRET doshQueryDiskFree(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1068	double *pdFree)
1069	{
1070	APIRET arc = NO_ERROR;
1071	FSALLOCATE fsa;
1072	// double dbl = -1;
1073
1074	if (!(arc = DosQueryFSInfo(ulLogicalDrive, FSIL_ALLOC, &fsa, sizeof(fsa))))
1075	pdFree = ((double)fsa.cSectorUnit fsa.cbSector * fsa.cUnitAvail);
1076	// ^ fixed V0.9.0
1077
1078	return (arc);
1079	}
1080
1081	/*
1082	*@@ doshQueryDiskFSType:
1083	* copies the file-system type of the given disk object
1084	* (HPFS, FAT, CDFS etc.) to pszBuf.
1085	* Returns the DOS error code.
1086	*
1087	*@@changed V0.9.1 (99-12-12) [umoeller]: added cbBuf to prototype
1088	*@@changed V0.9.14 (2001-08-01) [umoeller]: fixed, this never respected cbBuf
1089	*@@changed V0.9.16 (2001-10-02) [umoeller]: added check for valid logical disk no
1090	*/
1091
1092	APIRET doshQueryDiskFSType(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1093	PSZ pszBuf, // out: buffer for FS type
1094	ULONG cbBuf) // in: size of that buffer
1095	{
1096	APIRET arc = NO_ERROR;
1097	CHAR szName[5];
1098
1099	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
1100	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
1101	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
1102
1103	// compose "D:"-type string from logical drive letter
1104	if (ulLogicalDrive > 0 && ulLogicalDrive < 27)
1105	{
1106	szName[0] = ulLogicalDrive + 'A' - 1;
1107	szName[1] = ':';
1108	szName[2] = '\0';
1109
1110	arc = DosQueryFSAttach(szName, // logical drive of attached FS ("D:"-style)
1111	0, // ulOrdinal, ignored for FSAIL_QUERYNAME
1112	FSAIL_QUERYNAME, // return name for a drive or device
1113	pfsqBuffer, // buffer for returned data
1114	&cbBuffer); // sizeof(*pfsqBuffer)
1115
1116	if (arc == NO_ERROR)
1117	{
1118	if (pszBuf)
1119	{
1120	// The data for the last three fields in the FSQBUFFER2
1121	// structure are stored at the offset of fsqBuffer.szName.
1122	// Each data field following fsqBuffer.szName begins
1123	// immediately after the previous item.
1124	strncpy(pszBuf,
1125	(CHAR*)(&pfsqBuffer->szName) + pfsqBuffer->cbName + 1,
1126	cbBuf); // V0.9.14 (2001-08-01) [umoeller]
1127	*(pszBuf + cbBuf) = '\0';
1128	}
1129	}
1130	}
1131	else
1132	arc = ERROR_INVALID_PARAMETER; // V0.9.16 (2001-10-02) [umoeller]
1133
1134	return (arc);
1135	}
1136
1137	/*
1138	*@@ doshQueryDiskLabel:
1139	* this returns the label of a disk into
1140	* *pszVolumeLabel, which must be 12 bytes
1141	* in size.
1142	*
1143	* This function was added because the Toolkit
1144	* information for DosQueryFSInfo is only partly
1145	* correct. On OS/2 2.x, that function does not
1146	* take an FSINFO structure as input, but a VOLUMELABEL.
1147	* On Warp, this does take an FSINFO.
1148	*
1149	* DosSetFSInfo is even worse. See doshSetDiskLabel.
1150	*
1151	* See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
1152	* for details.
1153	*
1154	*@@added V0.9.0 [umoeller]
1155	*@@changed V0.9.11 (2001-04-22) [umoeller]: this copied even with errors, fixed
1156	*/
1157
1158	APIRET doshQueryDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1159	PSZ pszVolumeLabel) // out: volume label (must be 12 chars in size)
1160	{
1161	APIRET arc;
1162
1163	#ifdef __OS2V2X__
1164	VOLUMELABEL FSInfoBuf;
1165	#else
1166	FSINFO FSInfoBuf;
1167	#endif
1168
1169	arc = DosQueryFSInfo(ulLogicalDrive,
1170	FSIL_VOLSER,
1171	&FSInfoBuf,
1172	sizeof(FSInfoBuf)); // depends
1173
1174	if (!arc) // V0.9.11 (2001-04-22) [umoeller]
1175	{
1176	#ifdef __OS2V2X__
1177	strcpy(pszVolumeLabel, FSInfoBuf.szVolLabel);
1178	#else
1179	strcpy(pszVolumeLabel, FSInfoBuf.vol.szVolLabel);
1180	#endif
1181	}
1182
1183	return (arc);
1184	}
1185
1186	/*
1187	*@@ doshSetDiskLabel:
1188	* this sets the label of a disk.
1189	*
1190	* This function was added because the Toolkit
1191	* information for DosSetFSInfo is flat out wrong.
1192	* That function does not take an FSINFO structure
1193	* as input, but a VOLUMELABEL. As a result, using
1194	* that function with the Toolkit's calling specs
1195	* results in ERROR_LABEL_TOO_LONG always.
1196	*
1197	* See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
1198	* for details.
1199	*
1200	*@@added V0.9.0 [umoeller]
1201	*/
1202
1203	APIRET doshSetDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1204	PSZ pszNewLabel)
1205	{
1206	VOLUMELABEL FSInfoBuf;
1207
1208	// check length; 11 chars plus null byte allowed
1209	FSInfoBuf.cch = (BYTE)strlen(pszNewLabel);
1210	if (FSInfoBuf.cch < sizeof(FSInfoBuf.szVolLabel))
1211	{
1212	strcpy(FSInfoBuf.szVolLabel, pszNewLabel);
1213
1214	return (DosSetFSInfo(ulLogicalDrive,
1215	FSIL_VOLSER,
1216	&FSInfoBuf,
1217	sizeof(FSInfoBuf)));
1218	}
1219	else
1220	return (ERROR_LABEL_TOO_LONG);
1221	}
1222
1223	/*
1224	*@@category: Helpers\Control program helpers\File name parsing
1225	*/
1226
1227	/* ******************************************************************
1228	*
1229	* File name parsing
1230	*
1231	********************************************************************/
1232
1233	/*
1234	*@@ doshGetDriveSpec:
1235	* returns the drive specification in pcszFullFile,
1236	* if any is present. This is useful for UNC support.
1237	*
1238	* This returns:
1239	*
1240	* -- NO_ERROR: drive spec was given, and the output
1241	* fields have been set.
1242	*
1243	* -- ERROR_INVALID_NAME: incorrect UNC syntax.
1244	*
1245	* -- ERROR_INVALID_DRIVE: second char is ':', but
1246	* drive letter is not in the range [A-Z].
1247	*
1248	* -- ERROR_INVALID_PARAMETER: no drive spec given
1249	* at all; apparently pcszFullFile is not fully
1250	* qualified in the first place, or it is NULL,
1251	* or its length is <= 2.
1252	*
1253	*@@added V0.9.16 (2001-10-25) [umoeller]
1254	*/
1255
1256	APIRET doshGetDriveSpec(PCSZ pcszFullFile, // in: fully q'fied file spec
1257	PSZ pszDrive, // out: drive spec ("C:" or "\\SERVER\RESOURCE"; ptr can be NULL)
1258	PULONG pulDriveLen, // out: length of drive spec (2 if local drive; ptr can be NULL)
1259	PBOOL pfIsUNC) // out: set to TRUE if UNC name, FALSE otherwise (ptr can be NULL)
1260	{
1261	APIRET arc = NO_ERROR;
1262	ULONG ulFileSpecLength;
1263
1264	if ( (pcszFullFile)
1265	&& (ulFileSpecLength = strlen(pcszFullFile))
1266	&& (ulFileSpecLength >= 2)
1267	)
1268	{
1269	// upper-case the drive letter
1270	if (pcszFullFile[1] == ':')
1271	{
1272	CHAR cDrive = toupper(*pcszFullFile);
1273	// local drive specified:
1274	if ( (cDrive >= 'A')
1275	&& (cDrive <= 'Z')
1276	)
1277	{
1278	if (pszDrive)
1279	{
1280	pszDrive[0] = cDrive;
1281	pszDrive[1] = ':';
1282	pszDrive[2] = '\0';
1283	}
1284
1285	if (pulDriveLen)
1286	*pulDriveLen = 2;
1287	if (pfIsUNC)
1288	*pfIsUNC = FALSE;
1289	}
1290	else
1291	// this is not a valid drive:
1292	arc = ERROR_INVALID_DRIVE;
1293	}
1294	else if ( (pcszFullFile[0] == '\\')
1295	&& (pcszFullFile[1] == '\\')
1296	)
1297	{
1298	// UNC drive specified:
1299	// this better be a full \\SERVER\RESOURCE string
1300	PCSZ pResource;
1301	if (pResource = strchr(pcszFullFile + 3, '\\'))
1302	{
1303	// we got at least \\SERVER\:
1304	ULONG ulLength;
1305	PCSZ p;
1306
1307	// check if more stuff is coming
1308	if (p = strchr(pResource + 1, '\\'))
1309	{
1310	// yes: copy server and resource excluding that backslash
1311	if (p == pResource + 1)
1312	// "\\SERVER\\" is invalid
1313	arc = ERROR_INVALID_NAME;
1314	else
1315	// we got "\\SERVER\something\":
1316	// drop the last backslash
1317	ulLength = p - pcszFullFile;
1318	}
1319	else
1320	// "\\SERVER\something" only:
1321	ulLength = ulFileSpecLength;
1322
1323	if (!arc)
1324	{
1325	if (pszDrive)
1326	{
1327	memcpy(pszDrive,
1328	pcszFullFile,
1329	ulLength);
1330	pszDrive[ulLength] = '\0';
1331	}
1332
1333	if (pulDriveLen)
1334	*pulDriveLen = ulLength;
1335	if (pfIsUNC)
1336	*pfIsUNC = TRUE;
1337	}
1338	}
1339	else
1340	// invalid UNC name:
1341	arc = ERROR_INVALID_NAME;
1342	}
1343	else
1344	// neither local, nor UNC:
1345	arc = ERROR_INVALID_PARAMETER;
1346	}
1347	else
1348	arc = ERROR_INVALID_PARAMETER;
1349
1350	return (arc);
1351	}
1352
1353	/*
1354	*@@ doshGetExtension:
1355	* finds the file name extension of pszFilename,
1356	* which can be a file name only or a fully
1357	* qualified filename.
1358	*
1359	* This returns a pointer into pszFilename to
1360	* the character after the last dot.
1361	*
1362	* Returns NULL if not found (e.g. if the filename
1363	* has no dot in it).
1364	*
1365	* In the pathological case of a dot in the path
1366	* but not in the filename itself, this correctly
1367	* returns NULL.
1368	*
1369	*@@added V0.9.6 (2000-10-16) [umoeller]
1370	*@@changed V0.9.7 (2000-12-10) [umoeller]: fixed "F:filename.ext" case
1371	*/
1372
1373	PSZ doshGetExtension(PCSZ pcszFilename)
1374	{
1375	PSZ pReturn = NULL;
1376
1377	if (pcszFilename)
1378	{
1379	// find filename
1380	PCSZ p2,
1381	pStartOfName = NULL,
1382	pExtension = NULL;
1383
1384	if (p2 = strrchr(pcszFilename + 2, '\\'))
1385	// works on "C:\blah" or "\\unc\blah"
1386	pStartOfName = p2 + 1;
1387	else
1388	{
1389	// no backslash found:
1390	// maybe only a drive letter was specified:
1391	if (pcszFilename[1] == ':')
1392	// yes:
1393	pStartOfName = pcszFilename + 2;
1394	else
1395	// then this is not qualified at all...
1396	// use start of filename
1397	pStartOfName = (PSZ)pcszFilename;
1398	}
1399
1400	// find last dot in filename
1401	if (pExtension = strrchr(pStartOfName, '.'))
1402	pReturn = (PSZ)pExtension + 1;
1403	}
1404
1405	return (pReturn);
1406	}
1407
1408	/*
1409	*@@category: Helpers\Control program helpers\File management
1410	*/
1411
1412	/* ******************************************************************
1413	*
1414	* File helpers
1415	*
1416	********************************************************************/
1417
1418	/*
1419	*@@ doshIsFileOnFAT:
1420	* returns TRUE if pszFileName resides on
1421	* a FAT drive. Note that pszFileName must
1422	* be fully qualified (i.e. the drive letter
1423	* must be the first character), or this will
1424	* return garbage.
1425	*/
1426
1427	BOOL doshIsFileOnFAT(const char* pcszFileName)
1428	{
1429	BOOL brc = FALSE;
1430	CHAR szName[5];
1431
1432	APIRET rc = NO_ERROR; // return code
1433	BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
1434	ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
1435	PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
1436
1437	szName[0] = pcszFileName[0]; // copy drive letter
1438	szName[1] = ':';
1439	szName[2] = '\0';
1440
1441	rc = DosQueryFSAttach(szName, // logical drive of attached FS
1442	0, // ulOrdinal, ignored for FSAIL_QUERYNAME
1443	FSAIL_QUERYNAME, // return data for a Drive or Device
1444	pfsqBuffer, // returned data
1445	&cbBuffer); // returned data length
1446
1447	if (rc == NO_ERROR)
1448	{
1449	// The data for the last three fields in the FSQBUFFER2
1450	// structure are stored at the offset of fsqBuffer.szName.
1451	// Each data field following fsqBuffer.szName begins
1452	// immediately after the previous item.
1453	if (!strncmp((PSZ)&(pfsqBuffer->szName) + pfsqBuffer->cbName + 1,
1454	"FAT",
1455	3))
1456	brc = TRUE;
1457	}
1458
1459	return (brc);
1460	}
1461
1462	/*
1463	*@@ doshQueryFileSize:
1464	* returns the size of an already opened file
1465	* or 0 upon errors.
1466	* Use doshQueryPathSize to query the size of
1467	* any file.
1468	*
1469	*@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
1470	*/
1471
1472	APIRET doshQueryFileSize(HFILE hFile, // in: file handle
1473	PULONG pulSize) // out: file size (ptr can be NULL)
1474	{
1475	APIRET arc;
1476	FILESTATUS3 fs3;
1477	if (!(arc = DosQueryFileInfo(hFile, FIL_STANDARD, &fs3, sizeof(fs3))))
1478	if (pulSize)
1479	*pulSize = fs3.cbFile;
1480	return (arc);
1481	}
1482
1483	/*
1484	*@@ doshQueryPathSize:
1485	* returns the size of any file,
1486	* or 0 if the file could not be
1487	* found.
1488	*
1489	* Use doshQueryFileSize instead to query the
1490	* size if you have a HFILE.
1491	*
1492	* Otherwise this returns:
1493	*
1494	* -- ERROR_FILE_NOT_FOUND
1495	* -- ERROR_PATH_NOT_FOUND
1496	* -- ERROR_SHARING_VIOLATION
1497	* -- ERROR_FILENAME_EXCED_RANGE
1498	* -- ERROR_INVALID_PARAMETER
1499	*
1500	*@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
1501	*/
1502
1503	APIRET doshQueryPathSize(PCSZ pcszFile, // in: filename
1504	PULONG pulSize) // out: file size (ptr can be NULL)
1505	{
1506	APIRET arc;
1507
1508	if (pcszFile) // V0.9.16 (2001-12-08) [umoeller]
1509	{
1510	FILESTATUS3 fs3;
1511	if (!(arc = DosQueryPathInfo((PSZ)pcszFile, FIL_STANDARD, &fs3, sizeof(fs3))))
1512	if (pulSize)
1513	*pulSize = fs3.cbFile;
1514	}
1515	else
1516	arc = ERROR_INVALID_PARAMETER;
1517
1518	return (arc);
1519	}
1520
1521	/*
1522	*@@ doshQueryPathAttr:
1523	* returns the file attributes of pszFile,
1524	* which can be fully qualified. The
1525	* attributes will be stored in *pulAttr.
1526	* pszFile can also specify a directory,
1527	* although not all attributes make sense
1528	* for directories.
1529	*
1530	* fAttr can be:
1531	* -- FILE_ARCHIVED
1532	* -- FILE_READONLY
1533	* -- FILE_SYSTEM
1534	* -- FILE_HIDDEN
1535	*
1536	* This returns the APIRET of DosQueryPathInfo.
1537	* *pulAttr is only valid if NO_ERROR is
1538	* returned.
1539	*
1540	* Otherwise this returns:
1541	*
1542	* -- ERROR_FILE_NOT_FOUND
1543	* -- ERROR_PATH_NOT_FOUND
1544	* -- ERROR_SHARING_VIOLATION
1545	* -- ERROR_FILENAME_EXCED_RANGE
1546	*
1547	*@@added V0.9.0 [umoeller]
1548	*/
1549
1550	APIRET doshQueryPathAttr(const char* pcszFile, // in: file or directory name
1551	PULONG pulAttr) // out: attributes (ptr can be NULL)
1552	{
1553	FILESTATUS3 fs3;
1554	APIRET arc;
1555
1556	if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
1557	FIL_STANDARD,
1558	&fs3,
1559	sizeof(fs3))))
1560	{
1561	if (pulAttr)
1562	*pulAttr = fs3.attrFile;
1563	}
1564
1565	return (arc);
1566	}
1567
1568	/*
1569	*@@ doshSetPathAttr:
1570	* sets the file attributes of pszFile,
1571	* which can be fully qualified.
1572	* pszFile can also specify a directory,
1573	* although not all attributes make sense
1574	* for directories.
1575	*
1576	* fAttr can be:
1577	* -- FILE_ARCHIVED
1578	* -- FILE_READONLY
1579	* -- FILE_SYSTEM
1580	* -- FILE_HIDDEN
1581	*
1582	* Note that this simply sets all the given
1583	* attributes; the existing attributes
1584	* are lost.
1585	*
1586	* This returns the APIRET of DosQueryPathInfo.
1587	*/
1588
1589	APIRET doshSetPathAttr(const char* pcszFile, // in: file or directory name
1590	ULONG ulAttr) // in: new attributes
1591	{
1592	APIRET arc;
1593
1594	if (pcszFile)
1595	{
1596	FILESTATUS3 fs3;
1597	if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
1598	FIL_STANDARD,
1599	&fs3,
1600	sizeof(fs3))))
1601	{
1602	fs3.attrFile = ulAttr;
1603	arc = DosSetPathInfo((PSZ)pcszFile,
1604	FIL_STANDARD,
1605	&fs3,
1606	sizeof(fs3),
1607	DSPI_WRTTHRU);
1608	}
1609	}
1610	else
1611	arc = ERROR_INVALID_PARAMETER;
1612
1613	return (arc);
1614	}
1615
1616	/*
1617	*@@ doshOpenExisting:
1618	* opens an existing file for read-write access. Does
1619	* not create a new file if the file doesn't exist.
1620	*
1621	* This is just a simple wrapper around DosOpen.
1622	*
1623	* ulOpenFlags is passed to DosOpen. Should be one
1624	* of:
1625	*
1626	* -- for read-only access:
1627	*
1628	+ OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READONLY
1629	*
1630	* -- for read-write access:
1631	*
1632	+ OPEN_SHARE_DENYREADWRITE \| OPEN_ACCESS_READWRITE
1633	*
1634	* In addition, you can specify
1635	*
1636	+ OPEN_FLAGS_FAIL_ON_ERROR \| OPEN_FLAGS_RANDOM
1637	+ \| OPEN_FLAGS_NOINHERIT
1638	*
1639	*@@added V0.9.13 (2001-06-14) [umoeller]
1640	*/
1641
1642	/*
1643	APIRET doshOpenExisting(PCSZ pcszFilename, // in: file name
1644	ULONG ulOpenFlags, // in: open flags
1645	HFILE *phf) // out: OS/2 file handle
1646	{
1647	ULONG ulAction;
1648	return (DosOpen((PSZ)pcszFilename,
1649	phf,
1650	&ulAction,
1651	0, // cbFile
1652	0, // attributes
1653	OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS,
1654	ulOpenFlags,
1655	NULL)); // EAs
1656	}
1657	*/
1658
1659	/*
1660	* doshOpen:
1661	* wrapper around DosOpen for simpler opening
1662	* of files.
1663	*
1664	* ulOpenMode determines the mode to open the
1665	* file in (fptr specifies the position after
1666	* the open):
1667	*
1668	+ +-------------------------+------+------------+-----------+
1669	+ \| ulOpenMode \| mode \| if exists \| if new \|
1670	+ +-------------------------+------+------------+-----------+
1671	+ \| XOPEN_READ_EXISTING \| read \| opens \| fails \|
1672	+ \| \| \| fptr = 0 \| \|
1673	+ +-------------------------+------+------------+-----------+
1674	+ \| XOPEN_READWRITE_EXISTING r/w \| opens \| fails \|
1675	+ \| \| \| fptr = 0 \| \|
1676	+ +-------------------------+------+------------+-----------+
1677	+ \| XOPEN_READWRITE_APPEND \| r/w \| opens, \| creates \|
1678	+ \| \| \| appends \| \|
1679	+ \| \| \| fptr = end \| fptr = 0 \|
1680	+ +-------------------------+------+------------+-----------+
1681	+ \| XOPEN_READWRITE_NEW \| r/w \| replaces \| creates \|
1682	+ \| \| \| fptr = 0 \| fptr = 0 \|
1683	+ +-------------------------+------+------------+-----------+
1684	*
1685	* In addition, you can OR one of the above values with
1686	* the XOPEN_BINARY flag:
1687	*
1688	* -- If XOPEN_BINARY is set, no conversion is performed
1689	* on read and write.
1690	*
1691	* -- If XOPEN_BINARY is _not_ set, all \n chars are
1692	* converted to \r\n on write.
1693	*
1694	* *ppFile receives a new XFILE structure describing
1695	* the open file, if NO_ERROR is returned.
1696	*
1697	* The file pointer is then set to the beginning of the
1698	* file _unless_ XOPEN_READWRITE_APPEND was specified;
1699	* in that case only, the file pointer is set to the
1700	* end of the file so data can be appended (see above).
1701	*
1702	* Otherwise this returns:
1703	*
1704	* -- ERROR_FILE_NOT_FOUND
1705	* -- ERROR_PATH_NOT_FOUND
1706	* -- ERROR_SHARING_VIOLATION
1707	* -- ERROR_FILENAME_EXCED_RANGE
1708	*
1709	* -- ERROR_NOT_ENOUGH_MEMORY
1710	* -- ERROR_INVALID_PARAMETER
1711	*
1712	*@@added V0.9.16 (2001-10-19) [umoeller]
1713	*@@changed V0.9.16 (2001-12-18) [umoeller]: fixed error codes
1714	*/
1715
1716	APIRET doshOpen(PCSZ pcszFilename, // in: filename to open
1717	ULONG flOpenMode, // in: XOPEN_* mode
1718	PULONG pcbFile, // in: new file size (if new file is created)
1719	// out: file size
1720	PXFILE *ppFile)
1721	{
1722	APIRET arc = NO_ERROR;
1723
1724	ULONG fsOpenFlags = 0,
1725	fsOpenMode = OPEN_FLAGS_FAIL_ON_ERROR
1726	\| OPEN_FLAGS_NO_LOCALITY
1727	\| OPEN_FLAGS_NOINHERIT;
1728
1729	switch (flOpenMode & XOPEN_ACCESS_MASK)
1730	{
1731	case XOPEN_READ_EXISTING:
1732	fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
1733	\| OPEN_ACTION_OPEN_IF_EXISTS;
1734	fsOpenMode \|= OPEN_SHARE_DENYWRITE
1735	\| OPEN_ACCESS_READONLY;
1736
1737	// run this first, because if the file doesn't
1738	// exists, DosOpen only returns ERROR_OPEN_FAILED,
1739	// which isn't that meaningful
1740	// V0.9.16 (2001-12-08) [umoeller]
1741	arc = doshQueryPathSize(pcszFilename,
1742	pcbFile);
1743	break;
1744
1745	case XOPEN_READWRITE_EXISTING:
1746	fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
1747	\| OPEN_ACTION_OPEN_IF_EXISTS;
1748	fsOpenMode \|= OPEN_SHARE_DENYWRITE
1749	\| OPEN_ACCESS_READWRITE;
1750
1751	arc = doshQueryPathSize(pcszFilename,
1752	pcbFile);
1753	break;
1754
1755	case XOPEN_READWRITE_APPEND:
1756	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
1757	\| OPEN_ACTION_OPEN_IF_EXISTS;
1758	fsOpenMode \|= OPEN_SHARE_DENYREADWRITE
1759	\| OPEN_ACCESS_READWRITE;
1760	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_APPEND"));
1761	break;
1762
1763	case XOPEN_READWRITE_NEW:
1764	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
1765	\| OPEN_ACTION_REPLACE_IF_EXISTS;
1766	fsOpenMode \|= OPEN_SHARE_DENYREADWRITE
1767	\| OPEN_ACCESS_READWRITE;
1768	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_NEW"));
1769	break;
1770	}
1771
1772	if ((!arc) && fsOpenFlags && pcbFile && ppFile)
1773	{
1774	PXFILE pFile;
1775	if (pFile = NEW(XFILE))
1776	{
1777	ULONG ulAction;
1778
1779	ZERO(pFile);
1780
1781	// copy open flags
1782	pFile->flOpenMode = flOpenMode;
1783
1784	if (!(arc = DosOpen((PSZ)pcszFilename,
1785	&pFile->hf,
1786	&ulAction,
1787	*pcbFile,
1788	FILE_ARCHIVED,
1789	fsOpenFlags,
1790	fsOpenMode,
1791	NULL))) // EAs
1792	{
1793	// alright, got the file:
1794
1795	if ( (ulAction == FILE_EXISTED)
1796	&& ((flOpenMode & XOPEN_ACCESS_MASK) == XOPEN_READWRITE_APPEND)
1797	)
1798	// get its size and set ptr to end for append
1799	arc = DosSetFilePtr(pFile->hf,
1800	0,
1801	FILE_END,
1802	pcbFile);
1803	else
1804	arc = doshQueryFileSize(pFile->hf,
1805	pcbFile);
1806	// file ptr is at beginning
1807
1808	if (arc)
1809	_Pmpf((__FUNCTION__ ": DosSetFilePtr/queryfilesize returned %d for %s",
1810	arc, pcszFilename));
1811
1812	// store file size
1813	pFile->cbInitial
1814	= pFile->cbCurrent
1815	= *pcbFile;
1816
1817	pFile->pszFilename = strdup(pcszFilename);
1818	}
1819	else
1820	_Pmpf((__FUNCTION__ ": DosOpen returned %d for %s",
1821	arc, pcszFilename));
1822
1823	if (arc)
1824	doshClose(&pFile);
1825	else
1826	*ppFile = pFile;
1827	}
1828	else
1829	arc = ERROR_NOT_ENOUGH_MEMORY;
1830	}
1831	else
1832	arc = ERROR_INVALID_PARAMETER;
1833
1834	return (arc);
1835	}
1836
1837	/*
1838	*@@ doshLockFile:
1839	*
1840	*@@added V0.9.16 (2001-10-19) [umoeller]
1841	*/
1842
1843	APIRET doshLockFile(PXFILE pFile)
1844	{
1845	if (!pFile)
1846	return (ERROR_INVALID_PARAMETER);
1847
1848	if (!pFile->hmtx)
1849	// first call:
1850	return (DosCreateMutexSem(NULL,
1851	&pFile->hmtx,
1852	0,
1853	TRUE)); // request!
1854
1855	return (DosRequestMutexSem(pFile->hmtx, SEM_INDEFINITE_WAIT));
1856	}
1857
1858	/*
1859	*@@ doshUnlockFile:
1860	*
1861	*@@added V0.9.16 (2001-10-19) [umoeller]
1862	*/
1863
1864	APIRET doshUnlockFile(PXFILE pFile)
1865	{
1866	if (pFile)
1867	return (DosReleaseMutexSem(pFile->hmtx));
1868
1869	return (ERROR_INVALID_PARAMETER);
1870	}
1871
1872	/*
1873	*@@ doshReadAt:
1874	* reads cb bytes from the position specified by
1875	* lOffset into the buffer pointed to by pbData,
1876	* which should be cb bytes in size.
1877	*
1878	* Note that lOffset is always considered to
1879	* be from the beginning of the file (FILE_BEGIN
1880	* method).
1881	*
1882	* This implements a small cache so that several
1883	* calls with a near offset will not touch the
1884	* disk always. The cache has been optimized for
1885	* the exeh* functions and works quite nicely
1886	* there.
1887	*
1888	* Note that the position of the file pointer is
1889	* undefined after calling this function because
1890	* the data might have been returned from the
1891	* cache.
1892	*
1893	*@@added V0.9.13 (2001-06-14) [umoeller]
1894	*@@changed V0.9.16 (2001-12-18) [umoeller]: now with XFILE, and always using FILE_BEGIN
1895	*/
1896
1897	APIRET doshReadAt(PXFILE pFile,
1898	ULONG ulOffset, // in: offset to read from (from beginning of file)
1899	PULONG pcb, // in: bytes to read, out: bytes read
1900	PBYTE pbData) // out: read buffer (must be cb bytes)
1901	{
1902	APIRET arc;
1903	ULONG cb = *pcb;
1904	ULONG ulDummy;
1905
1906	if (!(arc = doshLockFile(pFile))) // this checks for pFile
1907	{
1908	*pcb = 0;
1909
1910	// check if we have the data in the cache already;
1911
1912	if ( (pFile->pbCache)
1913	// first byte must be in cache
1914	&& (ulOffset >= pFile->ulReadFrom)
1915	// last byte must be in cache
1916	&& ( ulOffset + cb
1917	<= pFile->ulReadFrom + pFile->cbCache
1918	)
1919	)
1920	{
1921	// alright, return data from cache simply
1922	ULONG ulOfsInCache = ulOffset - pFile->ulReadFrom;
1923
1924	memcpy(pbData,
1925	pFile->pbCache + ulOfsInCache,
1926	cb);
1927	*pcb = cb;
1928
1929	_Pmpf((__FUNCTION__ " %s: data is fully in cache",
1930	pFile->pszFilename));
1931	_Pmpf((" caller wants %d bytes from %d",
1932	cb, ulOffset));
1933	_Pmpf((" we got %d bytes from %d",
1934	pFile->cbCache, pFile->ulReadFrom));
1935	_Pmpf((" so copied %d bytes from cache ofs %d",
1936	cb, ulOfsInCache));
1937
1938	// still, advance the file pointer because
1939	// caller might run plain DosRead next
1940	/* DosSetFilePtr(pFile->hf,
1941	(LONG)ulOffset + cb,
1942	FILE_BEGIN,
1943	&ulDummy); */
1944	}
1945	else
1946	{
1947	// data is not in cache:
1948	// check how much it is... for small amounts,
1949	// we load the cache first
1950	if (cb <= 4096 - 512)
1951	{
1952	_Pmpf((__FUNCTION__ " %s: filling cache anew",
1953	pFile->pszFilename));
1954	_Pmpf((" caller wants %d bytes from %d",
1955	cb, ulOffset));
1956
1957	// OK, then fix the offset to read from
1958	// to a multiple of 512 to get a full sector
1959	pFile->ulReadFrom = ulOffset / 512L * 512L;
1960	// and read 4096 bytes always plus the
1961	// value we cut off above
1962	pFile->cbCache = 4096;
1963
1964	_Pmpf((" getting %d bytes from %d",
1965	pFile->cbCache, pFile->ulReadFrom));
1966
1967	// free old cache
1968	if (pFile->pbCache)
1969	free(pFile->pbCache);
1970
1971	// allocate new cache
1972	if (!(pFile->pbCache = (PBYTE)malloc(pFile->cbCache)))
1973	arc = ERROR_NOT_ENOUGH_MEMORY;
1974	else
1975	{
1976	if (!(arc = DosSetFilePtr(pFile->hf,
1977	(LONG)pFile->ulReadFrom,
1978	FILE_BEGIN,
1979	&ulDummy)))
1980	{
1981	if (!(arc = DosRead(pFile->hf,
1982	pFile->pbCache,
1983	pFile->cbCache,
1984	&ulDummy)))
1985	{
1986	// got data:
1987	ULONG ulOfsInCache;
1988
1989	_Pmpf((" %d bytes read", ulDummy));
1990	pFile->cbCache = ulDummy;
1991
1992	// copy to caller
1993	ulOfsInCache = ulOffset - pFile->ulReadFrom;
1994	memcpy(pbData,
1995	pFile->pbCache + ulOfsInCache,
1996	cb);
1997	*pcb = cb;
1998
1999	_Pmpf((" so copied %d bytes from cache ofs %d",
2000	cb, ulOfsInCache));
2001
2002	// still, advance the file pointer because
2003	// caller might run plain DosRead next
2004	/* DosSetFilePtr(pFile->hf,
2005	(LONG)ulOffset + cb,
2006	FILE_BEGIN,
2007	&ulDummy); */
2008	}
2009	}
2010
2011	if (arc)
2012	FREE(pFile->pbCache);
2013	}
2014	}
2015	else
2016	{
2017	// read uncached:
2018	_Pmpf((" " __FUNCTION__ " %s: reading uncached",
2019	pFile->pszFilename));
2020	_Pmpf((" caller wants %d bytes from %d",
2021	cb, ulOffset));
2022	if (!(arc = DosSetFilePtr(pFile->hf,
2023	(LONG)ulOffset,
2024	FILE_BEGIN,
2025	&ulDummy)))
2026	{
2027	if (!(arc = DosRead(pFile->hf,
2028	pbData,
2029	cb,
2030	&ulDummy)))
2031	*pcb = ulDummy; // bytes read
2032	}
2033	}
2034	}
2035
2036	doshUnlockFile(pFile);
2037	}
2038
2039	return (arc);
2040	}
2041
2042	/*
2043	*@@ doshWrite:
2044	* writes the specified data to the file.
2045	* If (cb == 0), this runs strlen on pcsz
2046	* to find out the length.
2047	*
2048	* If the file is not in binary mode, all
2049	* \n chars are converted to \r\n before
2050	* writing.
2051	*
2052	* Note that this expects that the file
2053	* pointer is at the end of the file, or
2054	* you will get garbage.
2055	*
2056	*@@added V0.9.16 (2001-10-19) [umoeller]
2057	*@@changed V0.9.16 (2001-12-02) [umoeller]: added XOPEN_BINARY \r\n support
2058	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
2059	*/
2060
2061	APIRET doshWrite(PXFILE pFile,
2062	ULONG cb,
2063	PCSZ pbData)
2064	{
2065	APIRET arc = NO_ERROR;
2066	if ((!pFile) \|\| (!pbData))
2067	arc = ERROR_INVALID_PARAMETER;
2068	else
2069	{
2070	if (!cb)
2071	cb = strlen(pbData);
2072
2073	if (!cb)
2074	arc = ERROR_INVALID_PARAMETER;
2075	else
2076	{
2077	PSZ pszNew = NULL;
2078
2079	if (!(pFile->flOpenMode & XOPEN_BINARY))
2080	{
2081	// convert all \n to \r\n:
2082	// V0.9.16 (2001-12-02) [umoeller]
2083
2084	// count all \n first
2085	ULONG cNewLines = 0;
2086	PCSZ pSource = pbData;
2087	ULONG ul;
2088	for (ul = 0;
2089	ul < cb;
2090	ul++)
2091	{
2092	if (*pSource++ == '\n')
2093	cNewLines++;
2094	}
2095
2096	if (cNewLines)
2097	{
2098	// we have '\n' chars:
2099	// then we need just as many \r chars inserted
2100	ULONG cbNew = cb + cNewLines;
2101	if (!(pszNew = (PSZ)malloc(cbNew)))
2102	arc = ERROR_NOT_ENOUGH_MEMORY;
2103	else
2104	{
2105	PSZ pTarget = pszNew;
2106	pSource = pbData;
2107	for (ul = 0;
2108	ul < cb;
2109	ul++)
2110	{
2111	CHAR c = *pSource++;
2112	if (c == '\n')
2113	*pTarget++ = '\r';
2114	*pTarget++ = c;
2115	}
2116
2117	cb = cbNew;
2118	}
2119	}
2120	}
2121
2122	if (!arc)
2123	if (!(arc = doshLockFile(pFile))) // this checks for pFile
2124	{
2125	ULONG cbWritten;
2126	if (!(arc = DosWrite(pFile->hf,
2127	(pszNew)
2128	? pszNew
2129	: (PSZ)pbData,
2130	cb,
2131	&cbWritten)))
2132	{
2133	pFile->cbCurrent += cbWritten;
2134	// invalidate the cache
2135	FREE(pFile->pbCache);
2136	}
2137
2138	doshUnlockFile(pFile);
2139	}
2140
2141	if (pszNew)
2142	free(pszNew);
2143	}
2144	}
2145
2146	return (arc);
2147	}
2148
2149	/*
2150	*@@ doshWriteAt:
2151	* writes cb bytes (pointed to by pbData) to the
2152	* specified file at the position lOffset (from
2153	* the beginning of the file).
2154	*
2155	*@@added V0.9.13 (2001-06-14) [umoeller]
2156	*/
2157
2158	APIRET doshWriteAt(PXFILE pFile,
2159	ULONG ulOffset, // in: offset to write at
2160	ULONG cb, // in: bytes to write
2161	PCSZ pbData) // in: ptr to bytes to write (must be cb bytes)
2162	{
2163	APIRET arc;
2164	if (!(arc = doshLockFile(pFile))) // this checks for pFile
2165	{
2166	ULONG cbWritten;
2167	if (!(arc = DosSetFilePtr(pFile->hf,
2168	(LONG)ulOffset,
2169	FILE_BEGIN,
2170	&cbWritten)))
2171	{
2172	if (!(arc = DosWrite(pFile->hf,
2173	(PSZ)pbData,
2174	cb,
2175	&cbWritten)))
2176	{
2177	if (ulOffset + cbWritten > pFile->cbCurrent)
2178	pFile->cbCurrent = ulOffset + cbWritten;
2179	}
2180	}
2181
2182	doshUnlockFile(pFile);
2183	}
2184
2185	return (arc);
2186	}
2187
2188	/*
2189	*@@ doshWriteLogEntry
2190	* writes a log string to an XFILE, adding a
2191	* leading timestamp before the line.
2192	*
2193	* The internal string buffer is limited to 2000
2194	* characters. Length checking is _not_ performed.
2195	*
2196	*@@added V0.9.16 (2001-10-19) [umoeller]
2197	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
2198	*/
2199
2200	APIRET doshWriteLogEntry(PXFILE pFile,
2201	const char* pcszFormat,
2202	...)
2203	{
2204	APIRET arc = NO_ERROR;
2205
2206	if ((!pFile) \|\| (!pcszFormat))
2207	arc = ERROR_INVALID_PARAMETER;
2208	else
2209	{
2210	DATETIME dt;
2211	CHAR szTemp[2000];
2212	ULONG ulLength;
2213
2214	DosGetDateTime(&dt);
2215	if (ulLength = sprintf(szTemp,
2216	"%04d-%02d-%02d %02d:%02d:%02d:%02d ",
2217	dt.year, dt.month, dt.day,
2218	dt.hours, dt.minutes, dt.seconds, dt.hundredths))
2219	{
2220	if (!(arc = doshWrite(pFile,
2221	ulLength,
2222	szTemp)))
2223	{
2224	va_list arg_ptr;
2225	va_start(arg_ptr, pcszFormat);
2226	ulLength = vsprintf(szTemp, pcszFormat, arg_ptr);
2227	va_end(arg_ptr);
2228
2229	if (pFile->flOpenMode & XOPEN_BINARY)
2230	// if we're in binary mode, we need to add \r too
2231	szTemp[ulLength++] = '\r';
2232	szTemp[ulLength++] = '\n';
2233
2234	arc = doshWrite(pFile,
2235	ulLength,
2236	szTemp);
2237	}
2238	}
2239	}
2240
2241	return (arc);
2242	}
2243
2244	/*
2245	* doshClose:
2246	*
2247	*@@added V0.9.16 (2001-10-19) [umoeller]
2248	*/
2249
2250	APIRET doshClose(PXFILE *ppFile)
2251	{
2252	APIRET arc = NO_ERROR;
2253	PXFILE pFile;
2254
2255	if ( (ppFile)
2256	&& (pFile = *ppFile)
2257	)
2258	{
2259	// request the mutex so that we won't be
2260	// taking the file away under someone's butt
2261	if (!(arc = doshLockFile(pFile)))
2262	{
2263	HMTX hmtx = pFile->hmtx;
2264	pFile->hmtx = NULLHANDLE;
2265
2266	// now that the file is locked,
2267	// set the ptr to NULL
2268	*ppFile = NULL;
2269
2270	FREE(pFile->pbCache);
2271	FREE(pFile->pszFilename);
2272
2273	if (pFile->hf)
2274	{
2275	DosSetFileSize(pFile->hf, pFile->cbCurrent);
2276	DosClose(pFile->hf);
2277	pFile->hf = NULLHANDLE;
2278	}
2279
2280	doshUnlockFile(pFile);
2281	DosCloseMutexSem(pFile->hmtx);
2282	}
2283
2284	free(pFile);
2285	}
2286	else
2287	arc = ERROR_INVALID_PARAMETER;
2288
2289	return (arc);
2290	}
2291
2292	/*
2293	*@@ doshLoadTextFile:
2294	* reads a text file from disk, allocates memory
2295	* via malloc() and sets a pointer to this
2296	* buffer (or NULL upon errors).
2297	*
2298	* This allocates one extra byte to make the
2299	* buffer null-terminated always. The buffer
2300	* is _not_ converted WRT the line format.
2301	*
2302	* This returns the APIRET of DosOpen and DosRead.
2303	* If any error occured, no buffer was allocated.
2304	* Otherwise, you should free() the buffer when
2305	* no longer needed.
2306	*
2307	*@@changed V0.9.7 (2001-01-15) [umoeller]: renamed from doshReadTextFile
2308	*@@changed V0.9.16 (2002-01-05) [umoeller]: added pcbRead
2309	*@@changed V0.9.16 (2002-01-05) [umoeller]: rewritten using doshOpen
2310	*/
2311
2312	APIRET doshLoadTextFile(PCSZ pcszFile, // in: file name to read
2313	PSZ* ppszContent, // out: newly allocated buffer with file's content
2314	PULONG pcbRead) // out: size of that buffer including null byte (ptr can be NULL)
2315	{
2316	APIRET arc;
2317
2318	ULONG cbFile = 0;
2319	PXFILE pFile = NULL;
2320
2321	if (!(arc = doshOpen(pcszFile,
2322	XOPEN_READ_EXISTING,
2323	&cbFile,
2324	&pFile)))
2325	{
2326	PSZ pszContent;
2327	if (!(pszContent = (PSZ)malloc(cbFile + 1)))
2328	arc = ERROR_NOT_ENOUGH_MEMORY;
2329	else
2330	{
2331	ULONG cbRead = 0;
2332	if (!(arc = DosRead(pFile->hf,
2333	pszContent,
2334	cbFile,
2335	&cbRead)))
2336	{
2337	if (cbRead != cbFile)
2338	arc = ERROR_NO_DATA;
2339	else
2340	{
2341	pszContent[cbRead] = '\0';
2342	*ppszContent = pszContent;
2343	}
2344	}
2345
2346	if (arc)
2347	free(pszContent);
2348	}
2349
2350	doshClose(&pFile);
2351	}
2352
2353	/*
2354	ULONG ulSize,
2355	ulBytesRead = 0,
2356	ulAction, ulLocal;
2357	HFILE hFile;
2358	PSZ pszContent = NULL;
2359
2360	APIRET arc;
2361
2362	*ppszContent = 0;
2363
2364	if (!(arc = DosOpen((PSZ)pcszFile,
2365	&hFile,
2366	&ulAction, // action taken
2367	5000L, // primary allocation size
2368	FILE_ARCHIVED \| FILE_NORMAL, // file attribute
2369	OPEN_ACTION_OPEN_IF_EXISTS, // open flags
2370	OPEN_FLAGS_NOINHERIT
2371	\| OPEN_SHARE_DENYNONE
2372	\| OPEN_ACCESS_READONLY, // read-only mode
2373	NULL))) // no EAs
2374	{
2375	if (!(arc = doshQueryFileSize(hFile, &ulSize)))
2376	{
2377	pszContent = (PSZ)malloc(ulSize+1);
2378
2379	if (!(arc = DosSetFilePtr(hFile,
2380	0L,
2381	FILE_BEGIN,
2382	&ulLocal)))
2383	if (!(arc = DosRead(hFile,
2384	pszContent,
2385	ulSize,
2386	&ulBytesRead)))
2387	{
2388	*(pszContent+ulBytesRead) = 0;
2389	// set output buffer pointer
2390	*ppszContent = pszContent;
2391
2392	if (pcbRead)
2393	*pcbRead = ulBytesRead + 1;
2394	}
2395
2396	if (arc)
2397	free(pszContent);
2398	}
2399	DosClose(hFile);
2400	}
2401	*/
2402
2403	return (arc);
2404	}
2405
2406	/*
2407	*@@ doshCreateBackupFileName:
2408	* creates a valid backup filename of pszExisting
2409	* with a numerical file name extension which does
2410	* not exist in the directory where pszExisting
2411	* resides.
2412	* Returns a PSZ to a new buffer which was allocated
2413	* using malloc().
2414	*
2415	* <B>Example:</B> returns "C:\CONFIG.002" for input
2416	* "C:\CONFIG.SYS" if "C:\CONFIG.001" already exists.
2417	*
2418	*@@changed V0.9.1 (99-12-13) [umoeller]: this crashed if pszExisting had no file extension
2419	*/
2420
2421	PSZ doshCreateBackupFileName(const char* pszExisting)
2422	{
2423	CHAR szFilename[CCHMAXPATH];
2424	PSZ pszLastDot;
2425	ULONG ulCount = 1;
2426	CHAR szCount[5];
2427	ULONG ulDummy;
2428
2429	strcpy(szFilename, pszExisting);
2430	pszLastDot = strrchr(szFilename, '.');
2431	if (!pszLastDot)
2432	// no dot in filename:
2433	pszLastDot = szFilename + strlen(szFilename);
2434	do
2435	{
2436	sprintf(szCount, ".%03lu", ulCount);
2437	strcpy(pszLastDot, szCount);
2438	ulCount++;
2439	} while (!doshQueryPathSize(szFilename, &ulDummy));
2440
2441	return (strdup(szFilename));
2442	}
2443
2444	/*
2445	*@@ doshCreateTempFileName:
2446	* produces a file name in the the specified directory
2447	* or $(TEMP) which presently doesn't exist. This
2448	* checks the directory for existing files, but does
2449	* not open the temp file.
2450	*
2451	* If (pcszDir != NULL), we look into that directory.
2452	* Otherwise we look into the directory specified
2453	* by the $(TEMP) environment variable.
2454	* If $(TEMP) is not set, $(TMP) is tried next.
2455	*
2456	* If the directory thus specified does not exist, the
2457	* root directory of the boot drive is used instead.
2458	* As a result, this function should be fairly bomb-proof.
2459	*
2460	* If (pcszExt != NULL), the temp file receives
2461	* that extension, or no extension otherwise.
2462	* Do not specify the dot in pcszExt.
2463	*
2464	* pszTempFileName receives the fully qualified
2465	* file name of the temp file in that directory
2466	* and must point to a buffer CCHMAXPATH in size.
2467	* The file name is 8+3 compliant if pcszExt does
2468	* not exceed three characters.
2469	*
2470	* If (pcszPrefix != NULL), the temp file name
2471	* is prefixed with pcszPrefix. Since the temp
2472	* file name must not exceed 8+3 letters, we
2473	* can only use ( 8 - strlen(pcszPrefix ) digits
2474	* for a random number to make the temp file name
2475	* unique. You must therefore use a maximum of
2476	* four characters for the prefix. Otherwise
2477	* ERROR_INVALID_PARAMETER is returned.
2478	*
2479	* Example: Assuming TEMP is set to C:\TEMP,
2480	+
2481	+ dosCreateTempFileName(szBuffer,
2482	+ NULL, // use $(TEMP)
2483	+ "pre", // prefix
2484	+ "tmp") // extension
2485	+
2486	* would produce something like "C:\TEMP\pre07FG2.tmp".
2487	*
2488	*@@added V0.9.9 (2001-04-04) [umoeller]
2489	*/
2490
2491	APIRET doshCreateTempFileName(PSZ pszTempFileName, // out: fully q'fied temp file name
2492	PCSZ pcszDir, // in: dir or NULL for %TEMP%
2493	PCSZ pcszPrefix, // in: prefix for temp file or NULL
2494	PCSZ pcszExt) // in: extension (without dot) or NULL
2495	{
2496	APIRET arc = NO_ERROR;
2497
2498	ULONG ulPrefixLen = (pcszPrefix)
2499	? strlen(pcszPrefix)
2500	: 0;
2501
2502	if ( (!pszTempFileName)
2503	\|\| (ulPrefixLen > 4)
2504	)
2505	arc = ERROR_INVALID_PARAMETER;
2506	else
2507	{
2508	CHAR szDir[CCHMAXPATH] = "";
2509	FILESTATUS3 fs3;
2510
2511	const char *pcszTemp = pcszDir;
2512
2513	if (!pcszTemp)
2514	{
2515	if (!(pcszTemp = getenv("TEMP")))
2516	pcszTemp = getenv("TMP");
2517	}
2518
2519	if (pcszTemp) // either pcszDir or $(TEMP) or $(TMP) now
2520	if (DosQueryPathInfo((PSZ)pcszTemp,
2521	FIL_STANDARD,
2522	&fs3,
2523	sizeof(fs3)))
2524	// TEMP doesn't exist:
2525	pcszTemp = NULL;
2526
2527	if (!pcszTemp)
2528	// not set, or doesn't exist:
2529	// use root directory on boot drive
2530	sprintf(szDir,
2531	"%c:\\",
2532	doshQueryBootDrive());
2533	else
2534	{
2535	strcpy(szDir, pcszTemp);
2536	if (szDir[strlen(szDir) - 1] != '\\')
2537	strcat(szDir, "\\");
2538	}
2539
2540	if (!szDir[0])
2541	arc = ERROR_PATH_NOT_FOUND; // shouldn't happen
2542	else
2543	{
2544	ULONG ulRandom = 0;
2545	ULONG cAttempts = 0;
2546
2547	// produce random number
2548	DosQuerySysInfo(QSV_MS_COUNT,
2549	QSV_MS_COUNT,
2550	&ulRandom,
2551	sizeof(ulRandom));
2552
2553	do
2554	{
2555	CHAR szFile[20] = "",
2556	szFullTryThis[CCHMAXPATH];
2557
2558	// use the lower eight hex digits of the
2559	// system uptime as the temp dir name
2560	sprintf(szFile,
2561	"%08lX",
2562	ulRandom & 0xFFFFFFFF);
2563
2564	// if prefix is specified, overwrite the
2565	// first characters in the random number
2566	if (pcszPrefix)
2567	memcpy(szFile, pcszPrefix, ulPrefixLen);
2568
2569	if (pcszExt)
2570	{
2571	szFile[8] = '.';
2572	strcpy(szFile + 9, pcszExt);
2573	}
2574
2575	// now compose full temp file name
2576	strcpy(szFullTryThis, szDir);
2577	strcat(szFullTryThis, szFile);
2578	// now we have: "C:\temp\wpiXXXXX"
2579	if (DosQueryPathInfo(szFullTryThis,
2580	FIL_STANDARD,
2581	&fs3,
2582	sizeof(fs3))
2583	== ERROR_FILE_NOT_FOUND)
2584	{
2585	// file or dir doesn't exist:
2586	// cool, we're done
2587	strcpy(pszTempFileName, szFullTryThis);
2588	return (NO_ERROR);
2589	}
2590
2591	// if this didn't work, raise ulRandom and try again
2592	ulRandom += 123;
2593
2594	// try only 100 times, just to be sure
2595	cAttempts++;
2596	} while (cAttempts < 100);
2597
2598	// 100 loops elapsed:
2599	arc = ERROR_BAD_FORMAT;
2600	}
2601	}
2602
2603	return (arc);
2604	}
2605
2606	/*
2607	*@@ doshWriteTextFile:
2608	* writes a text file to disk; pszFile must contain the
2609	* whole path and filename.
2610	*
2611	* An existing file will be backed up if (pszBackup != NULL),
2612	* using doshCreateBackupFileName. In that case, pszBackup
2613	* receives the name of the backup created, so that buffer
2614	* should be CCHMAXPATH in size.
2615	*
2616	* If (pszbackup == NULL), an existing file will be overwritten.
2617	*
2618	* On success (NO_ERROR returned), *pulWritten receives
2619	* the no. of bytes written.
2620	*
2621	*@@changed V0.9.3 (2000-05-01) [umoeller]: optimized DosOpen; added error checking; changed prototype
2622	*@@changed V0.9.3 (2000-05-12) [umoeller]: added pszBackup
2623	*/
2624
2625	APIRET doshWriteTextFile(const char* pszFile, // in: file name
2626	const char* pszContent, // in: text to write
2627	PULONG pulWritten, // out: bytes written (ptr can be NULL)
2628	PSZ pszBackup) // in/out: create-backup?
2629	{
2630	APIRET arc = NO_ERROR;
2631	ULONG ulWritten = 0;
2632
2633	if ((!pszFile) \|\| (!pszContent))
2634	arc = ERROR_INVALID_PARAMETER;
2635	else
2636	{
2637	ULONG ulAction = 0,
2638	ulLocal = 0;
2639	HFILE hFile = 0;
2640
2641	ULONG ulSize = strlen(pszContent); // exclude 0 byte
2642
2643	if (pszBackup)
2644	{
2645	PSZ pszBackup2 = doshCreateBackupFileName(pszFile);
2646	DosCopy((PSZ)pszFile,
2647	pszBackup2,
2648	DCPY_EXISTING); // delete existing
2649	strcpy(pszBackup, pszBackup2);
2650	free(pszBackup2);
2651	}
2652
2653	if (!(arc = DosOpen((PSZ)pszFile,
2654	&hFile,
2655	&ulAction, // action taken
2656	ulSize, // primary allocation size
2657	FILE_ARCHIVED \| FILE_NORMAL, // file attribute
2658	OPEN_ACTION_CREATE_IF_NEW
2659	\| OPEN_ACTION_REPLACE_IF_EXISTS, // open flags
2660	OPEN_FLAGS_NOINHERIT
2661	\| OPEN_FLAGS_SEQUENTIAL // sequential, not random access
2662	\| OPEN_SHARE_DENYWRITE // deny write mode
2663	\| OPEN_ACCESS_WRITEONLY, // write mode
2664	NULL))) // no EAs
2665	{
2666	if (!(arc = DosSetFilePtr(hFile,
2667	0L,
2668	FILE_BEGIN,
2669	&ulLocal)))
2670	if (!(arc = DosWrite(hFile,
2671	(PVOID)pszContent,
2672	ulSize,
2673	&ulWritten)))
2674	arc = DosSetFileSize(hFile, ulSize);
2675
2676	DosClose(hFile);
2677	}
2678	} // end if ((pszFile) && (pszContent))
2679
2680	if (pulWritten)
2681	*pulWritten = ulWritten;
2682
2683	return (arc);
2684	}
2685
2686	/*
2687	*@@category: Helpers\Control program helpers\Directory management
2688	* directory helpers (querying, creating, deleting etc.).
2689	*/
2690
2691	/* ******************************************************************
2692	*
2693	* Directory helpers
2694	*
2695	********************************************************************/
2696
2697	/*
2698	*@@ doshQueryDirExist:
2699	* returns TRUE if the given directory
2700	* exists and really is a directory.
2701	*/
2702
2703	BOOL doshQueryDirExist(PCSZ pcszDir)
2704	{
2705	FILESTATUS3 fs3;
2706	APIRET arc;
2707
2708	if (!(arc = DosQueryPathInfo((PSZ)pcszDir,
2709	FIL_STANDARD,
2710	&fs3,
2711	sizeof(fs3))))
2712	// file found:
2713	return ((fs3.attrFile & FILE_DIRECTORY) != 0);
2714	else
2715	return FALSE;
2716	}
2717
2718	/*
2719	*@@ doshCreatePath:
2720	* this creates the specified directory.
2721	* As opposed to DosCreateDir, this
2722	* function can create several directories
2723	* at the same time, if the parent
2724	* directories do not exist yet.
2725	*/
2726
2727	APIRET doshCreatePath(PCSZ pcszPath,
2728	BOOL fHidden) // in: if TRUE, the new directories will get FILE_HIDDEN
2729	{
2730	APIRET arc0 = NO_ERROR;
2731	CHAR path[CCHMAXPATH];
2732	CHAR *cp, c;
2733	ULONG cbPath;
2734
2735	strcpy(path, pcszPath);
2736	cbPath = strlen(path);
2737
2738	if (path[cbPath] != '\\')
2739	{
2740	path[cbPath] = '\\';
2741	path[cbPath+1] = 0;
2742	}
2743
2744	cp = path;
2745	// advance past the drive letter only if we have one
2746	if (*(cp+1) == ':')
2747	cp += 3;
2748
2749	// go!
2750	while (*cp != 0)
2751	{
2752	if (*cp == '\\')
2753	{
2754	c = *cp;
2755	*cp = 0;
2756	if (!doshQueryDirExist(path))
2757	{
2758	APIRET arc = DosCreateDir(path,
2759	0); // no EAs
2760	if (arc != NO_ERROR)
2761	{
2762	arc0 = arc;
2763	break;
2764	}
2765	else
2766	if (fHidden)
2767	{
2768	// hide the directory we just created
2769	doshSetPathAttr(path, FILE_HIDDEN);
2770	}
2771	}
2772	*cp = c;
2773	}
2774	cp++;
2775	}
2776	return (arc0);
2777	}
2778
2779	/*
2780	*@@ doshQueryCurrentDir:
2781	* writes the current directory into
2782	* the specified buffer, which should be
2783	* CCHMAXPATH in size.
2784	*
2785	* As opposed to DosQueryCurrentDir, this
2786	* includes the drive letter.
2787	*
2788	*@@added V0.9.4 (2000-07-22) [umoeller]
2789	*/
2790
2791	APIRET doshQueryCurrentDir(PSZ pszBuf)
2792	{
2793	APIRET arc = NO_ERROR;
2794	ULONG ulCurDisk = 0;
2795	ULONG ulMap = 0;
2796	if (!(arc = DosQueryCurrentDisk(&ulCurDisk, &ulMap)))
2797	{
2798	ULONG cbBuf = CCHMAXPATH - 3;
2799	*pszBuf = ulCurDisk + 'A' - 1;
2800	*(pszBuf + 1) = ':';
2801	*(pszBuf + 2) = '\\';
2802	arc = DosQueryCurrentDir(0, pszBuf + 3, &cbBuf);
2803	}
2804
2805	return (arc);
2806	}
2807
2808	/*
2809	*@@ doshDeleteDir:
2810	* deletes a directory. As opposed to DosDeleteDir,
2811	* this removes empty subdirectories and/or files
2812	* as well.
2813	*
2814	* flFlags can be any combination of the following:
2815	*
2816	* -- DOSHDELDIR_RECURSE: recurse into subdirectories.
2817	*
2818	* -- DOSHDELDIR_DELETEFILES: delete all regular files
2819	* which are found on the way.
2820	*
2821	* THIS IS NOT IMPLEMENTED YET.
2822	*
2823	* If 0 is specified, this effectively behaves just as
2824	* DosDeleteDir.
2825	*
2826	* If you specify DOSHDELDIR_RECURSE only, only empty
2827	* subdirectories are deleted as well.
2828	*
2829	* If you specify DOSHDELDIR_RECURSE \| DOSHDELDIR_DELETEFILES,
2830	* this removes an entire directory tree, including all
2831	* subdirectories and files.
2832	*
2833	*@@added V0.9.4 (2000-07-01) [umoeller]
2834	*/
2835
2836	APIRET doshDeleteDir(PCSZ pcszDir,
2837	ULONG flFlags,
2838	PULONG pulDirs, // out: directories found
2839	PULONG pulFiles) // out: files found
2840	{
2841	APIRET arc = NO_ERROR,
2842	arcReturn = NO_ERROR;
2843
2844	HDIR hdirFindHandle = HDIR_CREATE;
2845	FILEFINDBUF3 ffb3 = {0}; // returned from FindFirst/Next
2846	ULONG ulResultBufLen = sizeof(FILEFINDBUF3);
2847	ULONG ulFindCount = 1; // look for 1 file at a time
2848
2849	CHAR szFileMask[2*CCHMAXPATH];
2850	sprintf(szFileMask, "%s\\*", pcszDir);
2851
2852	// find files
2853	arc = DosFindFirst(szFileMask,
2854	&hdirFindHandle, // directory search handle
2855	FILE_ARCHIVED \| FILE_DIRECTORY \| FILE_SYSTEM
2856	\| FILE_HIDDEN \| FILE_READONLY,
2857	// search attributes; include all, even dirs
2858	&ffb3, // result buffer
2859	ulResultBufLen, // result buffer length
2860	&ulFindCount, // number of entries to find
2861	FIL_STANDARD); // return level 1 file info
2862
2863	if (arc == NO_ERROR)
2864	{
2865	// keep finding the next file until there are no more files
2866	while (arc == NO_ERROR) // != ERROR_NO_MORE_FILES
2867	{
2868	if (ffb3.attrFile & FILE_DIRECTORY)
2869	{
2870	// we found a directory:
2871
2872	// ignore the pseudo-directories
2873	if ( (strcmp(ffb3.achName, ".") != 0)
2874	&& (strcmp(ffb3.achName, "..") != 0)
2875	)
2876	{
2877	// real directory:
2878	if (flFlags & DOSHDELDIR_RECURSE)
2879	{
2880	// recurse!
2881	CHAR szSubDir[2*CCHMAXPATH];
2882	sprintf(szSubDir, "%s\\%s", pcszDir, ffb3.achName);
2883	arcReturn = doshDeleteDir(szSubDir,
2884	flFlags,
2885	pulDirs,
2886	pulFiles);
2887	// this removes ffb3.achName as well
2888	}
2889	else
2890	{
2891	// directory, but no recursion:
2892	// report "access denied"
2893	// (this is what OS/2 reports with DosDeleteDir as well)
2894	arcReturn = ERROR_ACCESS_DENIED; // 5
2895	(*pulDirs)++;
2896	}
2897	}
2898	}
2899	else
2900	{
2901	// it's a file:
2902	arcReturn = ERROR_ACCESS_DENIED;
2903	(*pulFiles)++;
2904	}
2905
2906	if (arc == NO_ERROR)
2907	{
2908	ulFindCount = 1; // reset find count
2909	arc = DosFindNext(hdirFindHandle, // directory handle
2910	&ffb3, // result buffer
2911	ulResultBufLen, // result buffer length
2912	&ulFindCount); // number of entries to find
2913	}
2914	} // endwhile
2915
2916	DosFindClose(hdirFindHandle); // close our find handle
2917	}
2918
2919	if (arcReturn == NO_ERROR)
2920	// success so far:
2921	// delete our directory now
2922	arc = DosDeleteDir((PSZ)pcszDir);
2923
2924	return (arcReturn);
2925	}
2926
2927	/*
2928	*@@category: Helpers\Control program helpers\Module handling
2929	* helpers for importing functions from a module (DLL).
2930	*/
2931
2932	/* ******************************************************************
2933	*
2934	* Module handling helpers
2935	*
2936	********************************************************************/
2937
2938	/*
2939	*@@ doshResolveImports:
2940	* this function loads the module called pszModuleName
2941	* and resolves imports dynamically using DosQueryProcAddress.
2942	*
2943	* To specify the functions to be imported, a RESOLVEFUNCTION
2944	* array is used. In each of the array items, specify the
2945	* name of the function and a pointer to a function pointer
2946	* where to store the resolved address.
2947	*
2948	*@@added V0.9.3 (2000-04-29) [umoeller]
2949	*/
2950
2951	APIRET doshResolveImports(PSZ pszModuleName, // in: DLL to load
2952	HMODULE *phmod, // out: module handle
2953	PRESOLVEFUNCTION paResolves, // in/out: function resolves
2954	ULONG cResolves) // in: array item count (not array size!)
2955	{
2956	CHAR szName[CCHMAXPATH];
2957	APIRET arc;
2958
2959	if (!(arc = DosLoadModule(szName,
2960	sizeof(szName),
2961	pszModuleName,
2962	phmod)))
2963	{
2964	ULONG ul;
2965	for (ul = 0;
2966	ul < cResolves;
2967	ul++)
2968	{
2969	if (arc = DosQueryProcAddr(*phmod,
2970	0, // ordinal, ignored
2971	(PSZ)paResolves[ul].pcszFunctionName,
2972	paResolves[ul].ppFuncAddress))
2973	// error:
2974	break;
2975	}
2976
2977	if (arc)
2978	// V0.9.16 (2001-12-08) [umoeller]
2979	DosFreeModule(*phmod);
2980	}
2981
2982	return (arc);
2983	}
2984
2985	/*
2986	*@@category: Helpers\Control program helpers\Performance (CPU load) helpers
2987	* helpers around DosPerfSysCall.
2988	*/
2989
2990	/* ******************************************************************
2991	*
2992	* Performance Counters (CPU Load)
2993	*
2994	********************************************************************/
2995
2996	/*
2997	*@@ doshPerfOpen:
2998	* initializes the OS/2 DosPerfSysCall API for
2999	* the calling thread.
3000	*
3001	* Note: This API is not supported on all OS/2
3002	* versions. I believe it came up with some Warp 4
3003	* fixpak. The API is resolved dynamically by
3004	* this function (using DosQueryProcAddr).
3005	*
3006	* This properly initializes the internal counters
3007	* which the OS/2 kernel uses for this API. Apparently,
3008	* with newer kernels (FP13/14), IBM has chosen to no
3009	* longer do this automatically, which is the reason
3010	* why many "pulse" utilities display garbage with these
3011	* fixpaks.
3012	*
3013	* After NO_ERROR is returned, DOSHPERFSYS.cProcessors
3014	* contains the no. of processors found on the system.
3015	* All pointers in DOSHPERFSYS then point to arrays
3016	* which have exactly cProcessors array items.
3017	*
3018	* So after NO_ERROR was returned here, you can keep
3019	* calling doshPerfGet to get a current snapshot of the
3020	* IRQ and user loads for each CPU. Note that interrupts
3021	* are only processed on CPU 0 on SMP systems.
3022	*
3023	* Call doshPerfClose to clean up resources allocated
3024	* by this function.
3025	*
3026	* For more sample code, take a look at the "Pulse" widget
3027	* in the XWorkplace sources (src\xcenter\w_pulse.c).
3028	*
3029	* Example code:
3030	*
3031	+ PDOSHPERFSYS pPerf = NULL;
3032	+ APIRET arc;
3033	+ if (!(arc = arc = doshPerfOpen(&pPerf)))
3034	+ {
3035	+ // this should really be in a timer,
3036	+ // e.g. once per second
3037	+ ULONG ulCPU;
3038	+ if (!(arc = doshPerfGet(&pPerf)))
3039	+ {
3040	+ // go thru all CPUs
3041	+ for (ulCPU = 0; ulCPU < pPerf->cProcessors; ulCPU++)
3042	+ {
3043	+ LONG lUserLoadThis = pPerf->palLoads[ulCPU];
3044	+ ...
3045	+ }
3046	+ }
3047	+
3048	+ // clean up
3049	+ doshPerfClose(&pPerf);
3050	+ }
3051	+
3052	*
3053	*@@added V0.9.7 (2000-12-02) [umoeller]
3054	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3055	*/
3056
3057	APIRET doshPerfOpen(PDOSHPERFSYS *ppPerfSys) // out: new DOSHPERFSYS structure
3058	{
3059	APIRET arc = NO_ERROR;
3060
3061	// allocate DOSHPERFSYS structure
3062	*ppPerfSys = (PDOSHPERFSYS)malloc(sizeof(DOSHPERFSYS));
3063	if (!*ppPerfSys)
3064	arc = ERROR_NOT_ENOUGH_MEMORY;
3065	else
3066	{
3067	// initialize structure
3068	PDOSHPERFSYS pPerfSys = *ppPerfSys;
3069	memset(pPerfSys, 0, sizeof(*pPerfSys));
3070
3071	// resolve DosPerfSysCall API entry
3072	if (!(arc = DosLoadModule(NULL, 0, "DOSCALLS", &pPerfSys->hmod)))
3073	{
3074	if (!(arc = DosQueryProcAddr(pPerfSys->hmod,
3075	976,
3076	"DosPerfSysCall",
3077	(PFN*)(&pPerfSys->pDosPerfSysCall))))
3078	{
3079	// OK, we got the API: initialize!
3080	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_ENABLE, 0, 0, 0)))
3081	{
3082	pPerfSys->fInitialized = TRUE;
3083	// call CMD_KI_DISABLE later
3084
3085	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_PERF_INFO,
3086	0,
3087	(ULONG)(&pPerfSys->cProcessors),
3088	0)))
3089	{
3090	ULONG ul = 0,
3091	cProcs = pPerfSys->cProcessors,
3092	cbDouble = cProcs * sizeof(double),
3093	cbLong = cProcs * sizeof(LONG);
3094
3095	// allocate arrays
3096	if ( (!(pPerfSys->paCPUUtils = (PCPUUTIL)calloc(cProcs,
3097	sizeof(CPUUTIL))))
3098	\|\| (!(pPerfSys->padBusyPrev
3099	= (double*)malloc(cbDouble)))
3100	\|\| (!(pPerfSys->padTimePrev
3101	= (double*)malloc(cbDouble)))
3102	\|\| (!(pPerfSys->padIntrPrev
3103	= (double*)malloc(cbDouble)))
3104	\|\| (!(pPerfSys->palLoads
3105	= (PLONG)malloc(cbLong)))
3106	\|\| (!(pPerfSys->palIntrs
3107	= (PLONG)malloc(cbLong)))
3108	)
3109	arc = ERROR_NOT_ENOUGH_MEMORY;
3110	else
3111	{
3112	for (ul = 0; ul < cProcs; ul++)
3113	{
3114	pPerfSys->padBusyPrev[ul] = 0.0;
3115	pPerfSys->padTimePrev[ul] = 0.0;
3116	pPerfSys->padIntrPrev[ul] = 0.0;
3117	pPerfSys->palLoads[ul] = 0;
3118	pPerfSys->palIntrs[ul] = 0;
3119	}
3120	}
3121	}
3122	}
3123	} // end if (arc == NO_ERROR)
3124	} // end if (arc == NO_ERROR)
3125
3126	if (arc)
3127	// error: clean up
3128	doshPerfClose(ppPerfSys);
3129
3130	} // end else if (!*ppPerfSys)
3131
3132	return (arc);
3133	}
3134
3135	/*
3136	*@@ doshPerfGet:
3137	* calculates a current snapshot of the system load,
3138	* compared with the load which was calculated on
3139	* the previous call.
3140	*
3141	* If you want to continually measure the system CPU
3142	* load, this is the function you will want to call
3143	* regularly -- e.g. with a timer once per second.
3144	*
3145	* Call this ONLY if doshPerfOpen returned NO_ERROR,
3146	* or you'll get crashes.
3147	*
3148	* If this call returns NO_ERROR, you get LONG load
3149	* values for each CPU in the system in the arrays
3150	* in DOSHPERFSYS (in per-mille, 0-1000).
3151	*
3152	* There are two arrays:
3153	*
3154	* -- DOSHPERFSYS.palLoads contains the "user" load
3155	* for each CPU.
3156	*
3157	* -- DOSHPERFSYS.palIntrs contains the "IRQ" load
3158	* for each CPU.
3159	*
3160	* Sum up the two values to get the total load for
3161	* each CPU.
3162	*
3163	* For example, if there are two CPUs, after this call,
3164	*
3165	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
3166	* of the first CPU,
3167	*
3168	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
3169	* of the second CPU.
3170	*
3171	* See doshPerfOpen for example code.
3172	*
3173	*@@added V0.9.7 (2000-12-02) [umoeller]
3174	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3175	*/
3176
3177	APIRET doshPerfGet(PDOSHPERFSYS pPerfSys)
3178	{
3179	APIRET arc = NO_ERROR;
3180	if (!pPerfSys->pDosPerfSysCall)
3181	arc = ERROR_INVALID_PARAMETER;
3182	else
3183	{
3184	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_RDCNT,
3185	(ULONG)pPerfSys->paCPUUtils,
3186	0, 0)))
3187	{
3188	// go thru all processors
3189	ULONG ul = 0;
3190	for (; ul < pPerfSys->cProcessors; ul++)
3191	{
3192	PCPUUTIL pCPUUtilThis = &pPerfSys->paCPUUtils[ul];
3193
3194	double dTime = LL2F(pCPUUtilThis->ulTimeHigh,
3195	pCPUUtilThis->ulTimeLow);
3196	double dBusy = LL2F(pCPUUtilThis->ulBusyHigh,
3197	pCPUUtilThis->ulBusyLow);
3198	double dIntr = LL2F(pCPUUtilThis->ulIntrHigh,
3199	pCPUUtilThis->ulIntrLow);
3200
3201	double *pdBusyPrevThis = &pPerfSys->padBusyPrev[ul];
3202	double *pdTimePrevThis = &pPerfSys->padTimePrev[ul];
3203	double *pdIntrPrevThis = &pPerfSys->padIntrPrev[ul];
3204
3205	// avoid division by zero
3206	double dTimeDelta;
3207	if (dTimeDelta = (dTime - *pdTimePrevThis))
3208	{
3209	pPerfSys->palLoads[ul]
3210	= (LONG)( (double)( (dBusy - *pdBusyPrevThis)
3211	/ dTimeDelta
3212	* 1000.0
3213	)
3214	);
3215	pPerfSys->palIntrs[ul]
3216	= (LONG)( (double)( (dIntr - *pdIntrPrevThis)
3217	/ dTimeDelta
3218	* 1000.0
3219	)
3220	);
3221	}
3222	else
3223	{
3224	// no clear readings are available
3225	pPerfSys->palLoads[ul] = 0;
3226	pPerfSys->palIntrs[ul] = 0;
3227	}
3228
3229	*pdTimePrevThis = dTime;
3230	*pdBusyPrevThis = dBusy;
3231	*pdIntrPrevThis = dIntr;
3232	}
3233	}
3234	}
3235
3236	return (arc);
3237	}
3238
3239	/*
3240	*@@ doshPerfClose:
3241	* frees all resources allocated by doshPerfOpen.
3242	*
3243	*@@added V0.9.7 (2000-12-02) [umoeller]
3244	*@@changed V0.9.9 (2001-02-06) [umoeller]: removed disable; this broke the WarpCenter
3245	*@@changed V0.9.9 (2001-03-14) [umoeller]: fixed memory leak
3246	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3247	*/
3248
3249	APIRET doshPerfClose(PDOSHPERFSYS *ppPerfSys)
3250	{
3251	APIRET arc = NO_ERROR;
3252	PDOSHPERFSYS pPerfSys;
3253	if ( (!ppPerfSys)
3254	\|\| (!(pPerfSys = *ppPerfSys))
3255	)
3256	arc = ERROR_INVALID_PARAMETER;
3257	else
3258	{
3259	// do not call this, this messes up the WarpCenter V0.9.9 (2001-02-06) [umoeller]
3260	// if (pPerfSys->fInitialized) pPerfSys->pDosPerfSysCall(CMD_KI_DISABLE, 0, 0, 0);
3261
3262	if (pPerfSys->paCPUUtils)
3263	free(pPerfSys->paCPUUtils);
3264	if (pPerfSys->padBusyPrev)
3265	free(pPerfSys->padBusyPrev);
3266	if (pPerfSys->padTimePrev)
3267	free(pPerfSys->padTimePrev);
3268	if (pPerfSys->padIntrPrev)
3269	free(pPerfSys->padIntrPrev);
3270	if (pPerfSys->palLoads) // was missing V0.9.9 (2001-03-14) [umoeller]
3271	free(pPerfSys->palLoads);
3272	if (pPerfSys->palIntrs)
3273	free(pPerfSys->palIntrs);
3274
3275	if (pPerfSys->hmod)
3276	DosFreeModule(pPerfSys->hmod);
3277	free(pPerfSys);
3278	*ppPerfSys = NULL;
3279	}
3280
3281	return (arc);
3282	}
3283
3284	/*
3285	*@@category: Helpers\Control program helpers\Process management
3286	* helpers for starting subprocesses.
3287	*/
3288
3289	/* ******************************************************************
3290	*
3291	* Process helpers
3292	*
3293	********************************************************************/
3294
3295	static PVOID // G_pvGlobalInfoSeg = NULL,
3296	G_pvLocalInfoSeg = NULL;
3297
3298	USHORT _Far16 _Pascal Dos16GetInfoSeg(PSEL pselGlobal,
3299	PSEL pselLocal);
3300
3301	/*
3302	* GetInfoSegs:
3303	*
3304	*/
3305
3306	VOID GetInfoSegs(VOID)
3307	{
3308	SEL GlobalInfoSegSelector,
3309	LocalInfoSegSelector;
3310
3311	// get selectors (old 16-bit API; this gets called only once)
3312	Dos16GetInfoSeg(&GlobalInfoSegSelector,
3313	&LocalInfoSegSelector);
3314	// thunk
3315	/* G_pvGlobalInfoSeg = (PVOID)( (GlobalInfoSegSelector << 0x000D)
3316	& 0x01fff0000); */
3317	G_pvLocalInfoSeg = (PVOID)( (LocalInfoSegSelector << 0x000D)
3318	& 0x01fff0000);
3319	}
3320
3321	/*
3322	*@@ doshMyPID:
3323	* returns the PID of the current process.
3324	*
3325	* This uses an interesting hack which is way
3326	* faster than DosGetInfoBlocks.
3327	*
3328	*@@added V0.9.9 (2001-04-04) [umoeller]
3329	*/
3330
3331	ULONG doshMyPID(VOID)
3332	{
3333	if (!G_pvLocalInfoSeg)
3334	// first call:
3335	GetInfoSegs();
3336
3337	// PID is at offset 0 in the local info seg
3338	return (*(PUSHORT)G_pvLocalInfoSeg);
3339	}
3340
3341	/*
3342	*@@ doshMyTID:
3343	* returns the TID of the current thread.
3344	*
3345	* This uses an interesting hack which is way
3346	* faster than DosGetInfoBlocks.
3347	*
3348	*@@added V0.9.9 (2001-04-04) [umoeller]
3349	*/
3350
3351	ULONG doshMyTID(VOID)
3352	{
3353	if (!G_pvLocalInfoSeg)
3354	// first call:
3355	GetInfoSegs();
3356
3357	// TID is at offset 6 in the local info seg
3358	return (*(PUSHORT)((PBYTE)G_pvLocalInfoSeg + 6));
3359	}
3360
3361	/*
3362	*@@ doshExecVIO:
3363	* executes cmd.exe with the /c parameter
3364	* and pcszExecWithArgs. This is equivalent
3365	* to the C library system() function,
3366	* except that an OS/2 error code is returned
3367	* and that this works with the VAC subsystem
3368	* library.
3369	*
3370	* This uses DosExecPgm and handles the sick
3371	* argument passing.
3372	*
3373	* If NO_ERROR is returned, *plExitCode receives
3374	* the exit code of the process. If the process
3375	* was terminated abnormally, *plExitCode receives:
3376	*
3377	* -- -1: hard error halt
3378	* -- -2: 16-bit trap
3379	* -- -3: DosKillProcess
3380	* -- -4: 32-bit exception
3381	*
3382	*@@added V0.9.4 (2000-07-27) [umoeller]
3383	*/
3384
3385	APIRET doshExecVIO(PCSZ pcszExecWithArgs,
3386	PLONG plExitCode) // out: exit code (ptr can be NULL)
3387	{
3388	APIRET arc = NO_ERROR;
3389
3390	if (strlen(pcszExecWithArgs) > 255)
3391	arc = ERROR_INSUFFICIENT_BUFFER;
3392	else
3393	{
3394	CHAR szObj[CCHMAXPATH];
3395	RESULTCODES res = {0};
3396	CHAR szBuffer[300];
3397
3398	// DosExecPgm expects two args in szBuffer:
3399	// -- cmd.exe\0
3400	// -- then the actual argument, terminated by two 0 bytes.
3401	memset(szBuffer, 0, sizeof(szBuffer));
3402	strcpy(szBuffer, "cmd.exe\0");
3403	sprintf(szBuffer + 8, "/c %s",
3404	pcszExecWithArgs);
3405
3406	arc = DosExecPgm(szObj, sizeof(szObj),
3407	EXEC_SYNC,
3408	szBuffer,
3409	0,
3410	&res,
3411	"cmd.exe");
3412	if ((arc == NO_ERROR) && (plExitCode))
3413	{
3414	if (res.codeTerminate == 0)
3415	// normal exit:
3416	*plExitCode = res.codeResult;
3417	else
3418	*plExitCode = -((LONG)res.codeTerminate);
3419	}
3420	}
3421
3422	return (arc);
3423	}
3424
3425	/*
3426	*@@ doshQuickStartSession:
3427	* this is a shortcut to DosStartSession w/out having to
3428	* deal with all the messy parameters.
3429	*
3430	* This one starts pszPath as a child session and passes
3431	* pszParams to it.
3432	*
3433	* In usPgmCtl, OR any or none of the following (V0.9.0):
3434	* -- SSF_CONTROL_NOAUTOCLOSE (0x0008): do not close automatically.
3435	* This bit is used only for VIO Windowable apps and ignored
3436	* for all other applications.
3437	* -- SSF_CONTROL_MINIMIZE (0x0004)
3438	* -- SSF_CONTROL_MAXIMIZE (0x0002)
3439	* -- SSF_CONTROL_INVISIBLE (0x0001)
3440	* -- SSF_CONTROL_VISIBLE (0x0000)
3441	*
3442	* Specifying 0 will therefore auto-close the session and make it
3443	* visible.
3444	*
3445	* If (fWait), this function will create a termination queue
3446	* and not return until the child session has ended. Be warned,
3447	* this blocks the calling thread.
3448	*
3449	* Otherwise the function will return immediately.
3450	*
3451	* The session and process IDs of the child session will be
3452	* written to pulSID and ppid. Of course, in "wait" mode,
3453	* these are no longer valid after this function returns.
3454	*
3455	* Returns the error code of DosStartSession.
3456	*
3457	* Note: According to CPREF, calling DosStartSession calls
3458	* DosExecPgm in turn for all full-screen, VIO, and PM sessions.
3459	*
3460	*@@changed V0.9.0 [umoeller]: prototype changed to include usPgmCtl
3461	*@@changed V0.9.1 (99-12-30) [umoeller]: queue was sometimes not closed. Fixed.
3462	*@@changed V0.9.3 (2000-05-03) [umoeller]: added fForeground
3463	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed potential queue leak
3464	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed memory leak in wait mode; added pusReturn to prototype
3465	*/
3466
3467	APIRET doshQuickStartSession(PCSZ pcszPath, // in: program to start
3468	PCSZ pcszParams, // in: parameters for program
3469	BOOL fForeground, // in: if TRUE, session will be in foreground
3470	USHORT usPgmCtl, // in: STARTDATA.PgmControl
3471	BOOL fWait, // in: wait for termination?
3472	PULONG pulSID, // out: session ID (req.)
3473	PPID ppid, // out: process ID (req.)
3474	PUSHORT pusReturn) // out: in wait mode, session's return code (ptr can be NULL)
3475	{
3476	APIRET arc = NO_ERROR;
3477	// queue stuff
3478	const char *pcszQueueName = "\\queues\\xwphlpsw.que";
3479	HQUEUE hq = 0;
3480	PID qpid = 0;
3481
3482	if (fWait)
3483	{
3484	if (!(arc = DosCreateQueue(&hq,
3485	QUE_FIFO \| QUE_CONVERT_ADDRESS,
3486	(PSZ)pcszQueueName)))
3487	arc = DosOpenQueue(&qpid, &hq, (PSZ)pcszQueueName);
3488	}
3489
3490	if (!arc) // V0.9.14 (2001-08-03) [umoeller]
3491	{
3492	STARTDATA SData;
3493	CHAR szObjBuf[CCHMAXPATH];
3494
3495	SData.Length = sizeof(STARTDATA);
3496	SData.Related = SSF_RELATED_CHILD; //INDEPENDENT;
3497	SData.FgBg = (fForeground) ? SSF_FGBG_FORE : SSF_FGBG_BACK;
3498	// V0.9.3 (2000-05-03) [umoeller]
3499	SData.TraceOpt = SSF_TRACEOPT_NONE;
3500
3501	SData.PgmTitle = (PSZ)pcszPath; // title for window
3502	SData.PgmName = (PSZ)pcszPath;
3503	SData.PgmInputs = (PSZ)pcszParams;
3504
3505	SData.TermQ = (fWait) ? (PSZ)pcszQueueName : NULL;
3506	SData.Environment = 0;
3507	SData.InheritOpt = SSF_INHERTOPT_PARENT;
3508	SData.SessionType = SSF_TYPE_DEFAULT;
3509	SData.IconFile = 0;
3510	SData.PgmHandle = 0;
3511
3512	SData.PgmControl = usPgmCtl;
3513
3514	SData.InitXPos = 30;
3515	SData.InitYPos = 40;
3516	SData.InitXSize = 200;
3517	SData.InitYSize = 140;
3518	SData.Reserved = 0;
3519	SData.ObjectBuffer = szObjBuf;
3520	SData.ObjectBuffLen = (ULONG)sizeof(szObjBuf);
3521
3522	if ( (!(arc = DosStartSession(&SData, pulSID, ppid)))
3523	&& (fWait)
3524	)
3525	{
3526	// block on the termination queue, which is written
3527	// to when the subprocess ends
3528	REQUESTDATA rqdata;
3529	ULONG cbData = 0;
3530	PULONG pulData = NULL;
3531	BYTE elpri;
3532
3533	rqdata.pid = qpid;
3534	if (!(arc = DosReadQueue(hq, // in: queue handle
3535	&rqdata, // out: pid and ulData
3536	&cbData, // out: size of data returned
3537	(PVOID*)&pulData, // out: data returned
3538	0, // in: remove first element in queue
3539	0, // in: wait for queue data (block thread)
3540	&elpri, // out: element's priority
3541	0))) // in: event semaphore to be posted
3542	{
3543	if (!rqdata.ulData)
3544	{
3545	// child session ended:
3546	// V0.9.14 (2001-08-03) [umoeller]
3547
3548	// pulSID = (pulData) & 0xffff;
3549	if (pusReturn)
3550	pusReturn = ((pulData) >> 16) & 0xffff;
3551
3552	}
3553	// else: continue looping
3554
3555	if (pulData)
3556	DosFreeMem(pulData);
3557	}
3558	}
3559	}
3560
3561	if (hq)
3562	DosCloseQueue(hq);
3563
3564	return (arc);
3565	}
3566
3567

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

Download in other formats: