Context Navigation

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

Visit:

Last change on this file since 123 was 123, checked in by umoeller, 24 years ago
Lots of changes for icons and refresh.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 107.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 = 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	APIRET doshOpenExisting(PCSZ pcszFilename, // in: file name
1643	ULONG ulOpenFlags, // in: open flags
1644	HFILE *phf) // out: OS/2 file handle
1645	{
1646	ULONG ulAction;
1647	return (DosOpen((PSZ)pcszFilename,
1648	phf,
1649	&ulAction,
1650	0, // cbFile
1651	0, // attributes
1652	OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS,
1653	ulOpenFlags,
1654	NULL)); // EAs
1655	}
1656
1657	/*
1658	*@@ doshWriteAt:
1659	* writes cb bytes (pointed to by pbData) to the
1660	* position specified by ulMethod and lOffset into
1661	* the file specified by hf.
1662	*
1663	* If ulMethod is FILE_BEGIN, lOffset specifies the
1664	* offset from the beginning of the file. With
1665	* FILE_CURRENT, lOffset is considered from the
1666	* current file pointer, and with FILE_END, it is
1667	* considered from the end of the file.
1668	*
1669	*@@added V0.9.13 (2001-06-14) [umoeller]
1670	*/
1671
1672	APIRET doshWriteAt(HFILE hf, // in: OS/2 file handle
1673	LONG lOffset, // in: offset to write at (depends on ulMethod)
1674	ULONG ulMethod, // in: one of FILE_BEGIN, FILE_CURRENT, FILE_END
1675	ULONG cb, // in: bytes to write
1676	PBYTE pbData) // in: ptr to bytes to write (must be cb bytes)
1677	{
1678	APIRET arc;
1679	ULONG ulDummy;
1680	if (!(arc = DosSetFilePtr(hf,
1681	lOffset,
1682	ulMethod,
1683	&ulDummy)))
1684	arc = DosWrite(hf,
1685	pbData,
1686	cb,
1687	&ulDummy);
1688
1689	return (arc);
1690	}
1691
1692	/*
1693	*@@ doshReadAt:
1694	* reads cb bytes from the position specified by
1695	* ulMethod and lOffset into the buffer pointed to
1696	* by pbData, which should be cb bytes in size.
1697	*
1698	* Use lOffset and ulMethod as with doshWriteAt.
1699	*
1700	*@@added V0.9.13 (2001-06-14) [umoeller]
1701	*/
1702
1703	APIRET doshReadAt(HFILE hf, // in: OS/2 file handle
1704	LONG lOffset, // in: offset to write at (depends on ulMethod)
1705	ULONG ulMethod, // in: one of FILE_BEGIN, FILE_CURRENT, FILE_END
1706	PULONG pcb, // in: bytes to read, out: bytes read
1707	PBYTE pbData) // out: read buffer (must be cb bytes)
1708	{
1709	APIRET arc;
1710	ULONG cb = *pcb;
1711	ULONG ulDummy;
1712
1713	*pcb = 0;
1714
1715	if (!(arc = DosSetFilePtr(hf,
1716	lOffset,
1717	ulMethod,
1718	&ulDummy)))
1719	{
1720	if (!(arc = DosRead(hf,
1721	pbData,
1722	cb,
1723	&ulDummy)))
1724	*pcb = ulDummy; // bytes read
1725	}
1726
1727	return (arc);
1728	}
1729
1730	/*
1731	* doshOpen:
1732	* wrapper around DosOpen for simpler opening
1733	* of files.
1734	*
1735	* ulOpenMode determines the mode to open the
1736	* file in (fptr specifies the position after
1737	* the open):
1738	*
1739	+ +-------------------------+------+------------+-----------+
1740	+ \| ulOpenMode \| mode \| if exists \| if new \|
1741	+ +-------------------------+------+------------+-----------+
1742	+ \| XOPEN_READ_EXISTING \| read \| opens \| fails \|
1743	+ \| \| \| fptr = 0 \| \|
1744	+ +-------------------------+------+------------+-----------+
1745	+ \| XOPEN_READWRITE_APPEND \| r/w \| opens, \| creates \|
1746	+ \| \| \| appends \| \|
1747	+ \| \| \| fptr = end \| fptr = 0 \|
1748	+ +-------------------------+------+------------+-----------+
1749	+ \| XOPEN_READWRITE_NEW \| r/w \| replaces \| creates \|
1750	+ \| \| \| fptr = 0 \| fptr = 0 \|
1751	+ +-------------------------+------+------------+-----------+
1752	*
1753	* In addition, you can OR one of the above values with
1754	* the XOPEN_BINARY flag:
1755	*
1756	* -- If XOPEN_BINARY is set, no conversion is performed
1757	* on read and write.
1758	*
1759	* -- If XOPEN_BINARY is _not_ set, all \n chars are
1760	* converted to \r\n on write.
1761	*
1762	* *ppFile receives a new XFILE structure describing
1763	* the open file, if NO_ERROR is returned.
1764	*
1765	* The file pointer is then set to the beginning of the
1766	* file _unless_ XOPEN_READWRITE_APPEND was specified;
1767	* in that case only, the file pointer is set to the
1768	* end of the file so data can be appended (see above).
1769	*
1770	* Otherwise this returns:
1771	*
1772	* -- ERROR_FILE_NOT_FOUND
1773	* -- ERROR_PATH_NOT_FOUND
1774	* -- ERROR_SHARING_VIOLATION
1775	* -- ERROR_FILENAME_EXCED_RANGE
1776	*
1777	* -- ERROR_NOT_ENOUGH_MEMORY
1778	* -- ERROR_INVALID_PARAMETER
1779	*
1780	*@@added V0.9.16 (2001-10-19) [umoeller]
1781	*/
1782
1783	APIRET doshOpen(PCSZ pcszFilename, // in: filename to open
1784	ULONG flOpenMode, // in: XOPEN_* mode
1785	PULONG pcbFile, // in: new file size (if new file is created)
1786	// out: file size
1787	PXFILE *ppFile)
1788	{
1789	APIRET arc = NO_ERROR;
1790
1791	// run this first, because if the file doesn't
1792	// exists, DosOpen only returns ERROR_OPEN_FAILED,
1793	// which isn't that meaningful
1794	// V0.9.16 (2001-12-08) [umoeller]
1795	if (!(arc = doshQueryPathSize(pcszFilename,
1796	pcbFile)))
1797	{
1798	ULONG fsOpenFlags = 0,
1799	fsOpenMode = OPEN_FLAGS_FAIL_ON_ERROR
1800	\| OPEN_FLAGS_NO_LOCALITY
1801	\| OPEN_FLAGS_NOINHERIT;
1802
1803	switch (flOpenMode & XOPEN_ACCESS_MASK)
1804	{
1805	case XOPEN_READ_EXISTING:
1806	fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
1807	\| OPEN_ACTION_OPEN_IF_EXISTS;
1808	fsOpenMode \|= OPEN_SHARE_DENYWRITE
1809	\| OPEN_ACCESS_READONLY;
1810	// _Pmpf((__FUNCTION__ ": opening XOPEN_READ_EXISTING"));
1811	break;
1812
1813	case XOPEN_READWRITE_APPEND:
1814	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
1815	\| OPEN_ACTION_OPEN_IF_EXISTS;
1816	fsOpenMode \|= OPEN_SHARE_DENYREADWRITE
1817	\| OPEN_ACCESS_READWRITE;
1818	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_APPEND"));
1819	break;
1820
1821	case XOPEN_READWRITE_NEW:
1822	fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
1823	\| OPEN_ACTION_REPLACE_IF_EXISTS;
1824	fsOpenMode \|= OPEN_SHARE_DENYREADWRITE
1825	\| OPEN_ACCESS_READWRITE;
1826	// _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_NEW"));
1827	break;
1828	}
1829
1830	if ((!arc) && fsOpenFlags && pcbFile && ppFile)
1831	{
1832	PXFILE pFile;
1833	if (pFile = NEW(XFILE))
1834	{
1835	ULONG ulAction;
1836
1837	ZERO(pFile);
1838
1839	// copy open flags
1840	pFile->flOpenMode = flOpenMode;
1841
1842	if (!(arc = DosOpen((PSZ)pcszFilename,
1843	&pFile->hf,
1844	&ulAction,
1845	*pcbFile,
1846	FILE_ARCHIVED,
1847	fsOpenFlags,
1848	fsOpenMode,
1849	NULL))) // EAs
1850	{
1851	// alright, got the file:
1852
1853	if ( (ulAction == FILE_EXISTED)
1854	&& ((flOpenMode & XOPEN_ACCESS_MASK) == XOPEN_READWRITE_APPEND)
1855	)
1856	// get its size and set ptr to end for append
1857	arc = DosSetFilePtr(pFile->hf,
1858	0,
1859	FILE_END,
1860	pcbFile);
1861	else
1862	arc = doshQueryFileSize(pFile->hf,
1863	pcbFile);
1864	// file ptr is at beginning
1865
1866	// store file size
1867	pFile->cbInitial
1868	= pFile->cbCurrent
1869	= *pcbFile;
1870	}
1871
1872	if (arc)
1873	doshClose(&pFile);
1874	else
1875	*ppFile = pFile;
1876	}
1877	else
1878	arc = ERROR_NOT_ENOUGH_MEMORY;
1879	}
1880	else
1881	arc = ERROR_INVALID_PARAMETER;
1882	}
1883
1884	return (arc);
1885	}
1886
1887	/*
1888	*@@ doshLockFile:
1889	*
1890	*@@added V0.9.16 (2001-10-19) [umoeller]
1891	*/
1892
1893	APIRET doshLockFile(PXFILE pFile)
1894	{
1895	if (!pFile)
1896	return (ERROR_INVALID_PARAMETER);
1897
1898	if (!pFile->hmtx)
1899	// first call:
1900	return (DosCreateMutexSem(NULL,
1901	&pFile->hmtx,
1902	0,
1903	TRUE)); // request!
1904
1905	return (DosRequestMutexSem(pFile->hmtx, SEM_INDEFINITE_WAIT));
1906	}
1907
1908	/*
1909	*@@ doshUnlockFile:
1910	*
1911	*@@added V0.9.16 (2001-10-19) [umoeller]
1912	*/
1913
1914	APIRET doshUnlockFile(PXFILE pFile)
1915	{
1916	if (pFile)
1917	return (DosReleaseMutexSem(pFile->hmtx));
1918
1919	return (ERROR_INVALID_PARAMETER);
1920	}
1921
1922	/*
1923	*@@ doshWrite:
1924	* writes the specified data to the file.
1925	* If (cb == 0), this runs strlen on pcsz
1926	* to find out the length.
1927	*
1928	* If the file is not in binary mode, all
1929	* \n chars are converted to \r\n before
1930	* writing.
1931	*
1932	*@@added V0.9.16 (2001-10-19) [umoeller]
1933	*@@changed V0.9.16 (2001-12-02) [umoeller]: added XOPEN_BINARY \r\n support
1934	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
1935	*/
1936
1937	APIRET doshWrite(PXFILE pFile,
1938	PCSZ pcsz,
1939	ULONG cb)
1940	{
1941	APIRET arc = NO_ERROR;
1942	if ((!pFile) \|\| (!pcsz))
1943	arc = ERROR_INVALID_PARAMETER;
1944	else
1945	{
1946	if (!cb)
1947	cb = strlen(pcsz);
1948
1949	if (!cb)
1950	arc = ERROR_INVALID_PARAMETER;
1951	else
1952	{
1953	PSZ pszNew = NULL;
1954
1955	if (!(pFile->flOpenMode & XOPEN_BINARY))
1956	{
1957	// convert all \n to \r\n:
1958	// V0.9.16 (2001-12-02) [umoeller]
1959
1960	// count all \n first
1961	ULONG cNewLines = 0;
1962	PCSZ pSource = pcsz;
1963	ULONG ul;
1964	for (ul = 0;
1965	ul < cb;
1966	ul++)
1967	{
1968	if (*pSource++ == '\n')
1969	cNewLines++;
1970	}
1971
1972	if (cNewLines)
1973	{
1974	// we have '\n' chars:
1975	// then we need just as many \r chars inserted
1976	ULONG cbNew = cb + cNewLines;
1977	if (!(pszNew = (PSZ)malloc(cbNew)))
1978	arc = ERROR_NOT_ENOUGH_MEMORY;
1979	else
1980	{
1981	PSZ pTarget = pszNew;
1982	pSource = pcsz;
1983	for (ul = 0;
1984	ul < cb;
1985	ul++)
1986	{
1987	CHAR c = *pSource++;
1988	if (c == '\n')
1989	*pTarget++ = '\r';
1990	*pTarget++ = c;
1991	}
1992
1993	cb = cbNew;
1994	}
1995	}
1996	}
1997
1998	if (!arc)
1999	if (!(arc = doshLockFile(pFile))) // this checks for pFile
2000	{
2001	ULONG cbWritten;
2002	if (!(arc = DosWrite(pFile->hf,
2003	(pszNew)
2004	? pszNew
2005	: (PSZ)pcsz,
2006	cb,
2007	&cbWritten)))
2008	pFile->cbCurrent += cbWritten;
2009
2010	doshUnlockFile(pFile);
2011	}
2012
2013	if (pszNew)
2014	free(pszNew);
2015	}
2016	}
2017
2018	return (arc);
2019	}
2020
2021	/*
2022	*@@ doshWriteLogEntry
2023	* writes a log string to an XFILE, adding a
2024	* leading timestamp before the line.
2025	*
2026	* The internal string buffer is limited to 2000
2027	* characters. Length checking is _not_ performed.
2028	*
2029	*@@added V0.9.16 (2001-10-19) [umoeller]
2030	*@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
2031	*/
2032
2033	APIRET doshWriteLogEntry(PXFILE pFile,
2034	const char* pcszFormat,
2035	...)
2036	{
2037	APIRET arc = NO_ERROR;
2038
2039	if ((!pFile) \|\| (!pcszFormat))
2040	arc = ERROR_INVALID_PARAMETER;
2041	else
2042	{
2043	DATETIME dt;
2044	CHAR szTemp[2000];
2045	ULONG ulLength;
2046
2047	DosGetDateTime(&dt);
2048	if (ulLength = sprintf(szTemp,
2049	"%04d-%02d-%02d %02d:%02d:%02d:%02d ",
2050	dt.year, dt.month, dt.day,
2051	dt.hours, dt.minutes, dt.seconds, dt.hundredths))
2052	{
2053	if (!(arc = doshWrite(pFile,
2054	szTemp,
2055	ulLength)))
2056	{
2057	va_list arg_ptr;
2058	va_start(arg_ptr, pcszFormat);
2059	ulLength = vsprintf(szTemp, pcszFormat, arg_ptr);
2060	va_end(arg_ptr);
2061
2062	if (pFile->flOpenMode & XOPEN_BINARY)
2063	// if we're in binary mode, we need to add \r too
2064	szTemp[ulLength++] = '\r';
2065	szTemp[ulLength++] = '\n';
2066
2067	arc = doshWrite(pFile,
2068	(PCSZ)szTemp,
2069	ulLength);
2070	}
2071	}
2072	}
2073
2074	return (arc);
2075	}
2076
2077	/*
2078	* doshClose:
2079	*
2080	*@@added V0.9.16 (2001-10-19) [umoeller]
2081	*/
2082
2083	APIRET doshClose(PXFILE *ppFile)
2084	{
2085	APIRET arc = NO_ERROR;
2086	PXFILE pFile;
2087
2088	if ( (ppFile)
2089	&& (pFile = *ppFile)
2090	)
2091	{
2092	// request the mutex so that we won't be
2093	// taking the file away under someone's butt
2094	if (!(arc = doshLockFile(pFile)))
2095	{
2096	HMTX hmtx = pFile->hmtx;
2097	pFile->hmtx = NULLHANDLE;
2098
2099	// now that the file is locked,
2100	// set the ptr to NULL
2101	*ppFile = NULL;
2102
2103	if (pFile->hf)
2104	{
2105	DosSetFileSize(pFile->hf, pFile->cbCurrent);
2106	DosClose(pFile->hf);
2107	pFile->hf = NULLHANDLE;
2108	}
2109
2110	doshUnlockFile(pFile);
2111	DosCloseMutexSem(pFile->hmtx);
2112	}
2113
2114	free(pFile);
2115	}
2116	else
2117	arc = ERROR_INVALID_PARAMETER;
2118
2119	return (arc);
2120	}
2121
2122	/*
2123	*@@ doshLoadTextFile:
2124	* reads a text file from disk, allocates memory
2125	* via malloc() and sets a pointer to this
2126	* buffer (or NULL upon errors).
2127	*
2128	* This returns the APIRET of DosOpen and DosRead.
2129	* If any error occured, no buffer was allocated.
2130	* Otherwise, you should free() the buffer when
2131	* no longer needed.
2132	*
2133	*@@changed V0.9.7 (2001-01-15) [umoeller]: renamed from doshReadTextFile
2134	*/
2135
2136	APIRET doshLoadTextFile(PCSZ pcszFile, // in: file name to read
2137	PSZ* ppszContent) // out: newly allocated buffer with file's content
2138	{
2139	ULONG ulSize,
2140	ulBytesRead = 0,
2141	ulAction, ulLocal;
2142	HFILE hFile;
2143	PSZ pszContent = NULL;
2144
2145	APIRET arc;
2146
2147	*ppszContent = 0;
2148
2149	if (!(arc = DosOpen((PSZ)pcszFile,
2150	&hFile,
2151	&ulAction, // action taken
2152	5000L, // primary allocation size
2153	FILE_ARCHIVED \| FILE_NORMAL, // file attribute
2154	OPEN_ACTION_OPEN_IF_EXISTS, // open flags
2155	OPEN_FLAGS_NOINHERIT
2156	\| OPEN_SHARE_DENYNONE
2157	\| OPEN_ACCESS_READONLY, // read-only mode
2158	NULL))) // no EAs
2159	{
2160	if (!(arc = doshQueryFileSize(hFile, &ulSize)))
2161	{
2162	pszContent = (PSZ)malloc(ulSize+1);
2163
2164	if (!(arc = DosSetFilePtr(hFile,
2165	0L,
2166	FILE_BEGIN,
2167	&ulLocal)))
2168	if (!(arc = DosRead(hFile,
2169	pszContent,
2170	ulSize,
2171	&ulBytesRead)))
2172	{
2173	*(pszContent+ulBytesRead) = 0;
2174	// set output buffer pointer
2175	*ppszContent = pszContent;
2176	}
2177
2178	if (arc)
2179	free(pszContent);
2180	}
2181	DosClose(hFile);
2182	}
2183
2184	return (arc);
2185	}
2186
2187	/*
2188	*@@ doshCreateBackupFileName:
2189	* creates a valid backup filename of pszExisting
2190	* with a numerical file name extension which does
2191	* not exist in the directory where pszExisting
2192	* resides.
2193	* Returns a PSZ to a new buffer which was allocated
2194	* using malloc().
2195	*
2196	* <B>Example:</B> returns "C:\CONFIG.002" for input
2197	* "C:\CONFIG.SYS" if "C:\CONFIG.001" already exists.
2198	*
2199	*@@changed V0.9.1 (99-12-13) [umoeller]: this crashed if pszExisting had no file extension
2200	*/
2201
2202	PSZ doshCreateBackupFileName(const char* pszExisting)
2203	{
2204	CHAR szFilename[CCHMAXPATH];
2205	PSZ pszLastDot;
2206	ULONG ulCount = 1;
2207	CHAR szCount[5];
2208	ULONG ulDummy;
2209
2210	strcpy(szFilename, pszExisting);
2211	pszLastDot = strrchr(szFilename, '.');
2212	if (!pszLastDot)
2213	// no dot in filename:
2214	pszLastDot = szFilename + strlen(szFilename);
2215	do
2216	{
2217	sprintf(szCount, ".%03lu", ulCount);
2218	strcpy(pszLastDot, szCount);
2219	ulCount++;
2220	} while (!doshQueryPathSize(szFilename, &ulDummy));
2221
2222	return (strdup(szFilename));
2223	}
2224
2225	/*
2226	*@@ doshCreateTempFileName:
2227	* produces a file name in the the specified directory
2228	* or $(TEMP) which presently doesn't exist. This
2229	* checks the directory for existing files, but does
2230	* not open the temp file.
2231	*
2232	* If (pcszDir != NULL), we look into that directory.
2233	* Otherwise we look into the directory specified
2234	* by the $(TEMP) environment variable.
2235	* If $(TEMP) is not set, $(TMP) is tried next.
2236	*
2237	* If the directory thus specified does not exist, the
2238	* root directory of the boot drive is used instead.
2239	* As a result, this function should be fairly bomb-proof.
2240	*
2241	* If (pcszExt != NULL), the temp file receives
2242	* that extension, or no extension otherwise.
2243	* Do not specify the dot in pcszExt.
2244	*
2245	* pszTempFileName receives the fully qualified
2246	* file name of the temp file in that directory
2247	* and must point to a buffer CCHMAXPATH in size.
2248	* The file name is 8+3 compliant if pcszExt does
2249	* not exceed three characters.
2250	*
2251	* If (pcszPrefix != NULL), the temp file name
2252	* is prefixed with pcszPrefix. Since the temp
2253	* file name must not exceed 8+3 letters, we
2254	* can only use ( 8 - strlen(pcszPrefix ) digits
2255	* for a random number to make the temp file name
2256	* unique. You must therefore use a maximum of
2257	* four characters for the prefix. Otherwise
2258	* ERROR_INVALID_PARAMETER is returned.
2259	*
2260	* Example: Assuming TEMP is set to C:\TEMP,
2261	+
2262	+ dosCreateTempFileName(szBuffer,
2263	+ NULL, // use $(TEMP)
2264	+ "pre", // prefix
2265	+ "tmp") // extension
2266	+
2267	* would produce something like "C:\TEMP\pre07FG2.tmp".
2268	*
2269	*@@added V0.9.9 (2001-04-04) [umoeller]
2270	*/
2271
2272	APIRET doshCreateTempFileName(PSZ pszTempFileName, // out: fully q'fied temp file name
2273	PCSZ pcszDir, // in: dir or NULL for %TEMP%
2274	PCSZ pcszPrefix, // in: prefix for temp file or NULL
2275	PCSZ pcszExt) // in: extension (without dot) or NULL
2276	{
2277	APIRET arc = NO_ERROR;
2278
2279	ULONG ulPrefixLen = (pcszPrefix)
2280	? strlen(pcszPrefix)
2281	: 0;
2282
2283	if ( (!pszTempFileName)
2284	\|\| (ulPrefixLen > 4)
2285	)
2286	arc = ERROR_INVALID_PARAMETER;
2287	else
2288	{
2289	CHAR szDir[CCHMAXPATH] = "";
2290	FILESTATUS3 fs3;
2291
2292	const char *pcszTemp = pcszDir;
2293
2294	if (!pcszTemp)
2295	{
2296	if (!(pcszTemp = getenv("TEMP")))
2297	pcszTemp = getenv("TMP");
2298	}
2299
2300	if (pcszTemp) // either pcszDir or $(TEMP) or $(TMP) now
2301	if (DosQueryPathInfo((PSZ)pcszTemp,
2302	FIL_STANDARD,
2303	&fs3,
2304	sizeof(fs3)))
2305	// TEMP doesn't exist:
2306	pcszTemp = NULL;
2307
2308	if (!pcszTemp)
2309	// not set, or doesn't exist:
2310	// use root directory on boot drive
2311	sprintf(szDir,
2312	"%c:\\",
2313	doshQueryBootDrive());
2314	else
2315	{
2316	strcpy(szDir, pcszTemp);
2317	if (szDir[strlen(szDir) - 1] != '\\')
2318	strcat(szDir, "\\");
2319	}
2320
2321	if (!szDir[0])
2322	arc = ERROR_PATH_NOT_FOUND; // shouldn't happen
2323	else
2324	{
2325	ULONG ulRandom = 0;
2326	ULONG cAttempts = 0;
2327
2328	// produce random number
2329	DosQuerySysInfo(QSV_MS_COUNT,
2330	QSV_MS_COUNT,
2331	&ulRandom,
2332	sizeof(ulRandom));
2333
2334	do
2335	{
2336	CHAR szFile[20] = "",
2337	szFullTryThis[CCHMAXPATH];
2338
2339	// use the lower eight hex digits of the
2340	// system uptime as the temp dir name
2341	sprintf(szFile,
2342	"%08lX",
2343	ulRandom & 0xFFFFFFFF);
2344
2345	// if prefix is specified, overwrite the
2346	// first characters in the random number
2347	if (pcszPrefix)
2348	memcpy(szFile, pcszPrefix, ulPrefixLen);
2349
2350	if (pcszExt)
2351	{
2352	szFile[8] = '.';
2353	strcpy(szFile + 9, pcszExt);
2354	}
2355
2356	// now compose full temp file name
2357	strcpy(szFullTryThis, szDir);
2358	strcat(szFullTryThis, szFile);
2359	// now we have: "C:\temp\wpiXXXXX"
2360	if (DosQueryPathInfo(szFullTryThis,
2361	FIL_STANDARD,
2362	&fs3,
2363	sizeof(fs3))
2364	== ERROR_FILE_NOT_FOUND)
2365	{
2366	// file or dir doesn't exist:
2367	// cool, we're done
2368	strcpy(pszTempFileName, szFullTryThis);
2369	return (NO_ERROR);
2370	}
2371
2372	// if this didn't work, raise ulRandom and try again
2373	ulRandom += 123;
2374
2375	// try only 100 times, just to be sure
2376	cAttempts++;
2377	} while (cAttempts < 100);
2378
2379	// 100 loops elapsed:
2380	arc = ERROR_BAD_FORMAT;
2381	}
2382	}
2383
2384	return (arc);
2385	}
2386
2387	/*
2388	*@@ doshWriteTextFile:
2389	* writes a text file to disk; pszFile must contain the
2390	* whole path and filename.
2391	*
2392	* An existing file will be backed up if (pszBackup != NULL),
2393	* using doshCreateBackupFileName. In that case, pszBackup
2394	* receives the name of the backup created, so that buffer
2395	* should be CCHMAXPATH in size.
2396	*
2397	* If (pszbackup == NULL), an existing file will be overwritten.
2398	*
2399	* On success (NO_ERROR returned), *pulWritten receives
2400	* the no. of bytes written.
2401	*
2402	*@@changed V0.9.3 (2000-05-01) [umoeller]: optimized DosOpen; added error checking; changed prototype
2403	*@@changed V0.9.3 (2000-05-12) [umoeller]: added pszBackup
2404	*/
2405
2406	APIRET doshWriteTextFile(const char* pszFile, // in: file name
2407	const char* pszContent, // in: text to write
2408	PULONG pulWritten, // out: bytes written (ptr can be NULL)
2409	PSZ pszBackup) // in/out: create-backup?
2410	{
2411	APIRET arc = NO_ERROR;
2412	ULONG ulWritten = 0;
2413
2414	if ((!pszFile) \|\| (!pszContent))
2415	arc = ERROR_INVALID_PARAMETER;
2416	else
2417	{
2418	ULONG ulAction = 0,
2419	ulLocal = 0;
2420	HFILE hFile = 0;
2421
2422	ULONG ulSize = strlen(pszContent); // exclude 0 byte
2423
2424	if (pszBackup)
2425	{
2426	PSZ pszBackup2 = doshCreateBackupFileName(pszFile);
2427	DosCopy((PSZ)pszFile,
2428	pszBackup2,
2429	DCPY_EXISTING); // delete existing
2430	strcpy(pszBackup, pszBackup2);
2431	free(pszBackup2);
2432	}
2433
2434	if (!(arc = DosOpen((PSZ)pszFile,
2435	&hFile,
2436	&ulAction, // action taken
2437	ulSize, // primary allocation size
2438	FILE_ARCHIVED \| FILE_NORMAL, // file attribute
2439	OPEN_ACTION_CREATE_IF_NEW
2440	\| OPEN_ACTION_REPLACE_IF_EXISTS, // open flags
2441	OPEN_FLAGS_NOINHERIT
2442	\| OPEN_FLAGS_SEQUENTIAL // sequential, not random access
2443	\| OPEN_SHARE_DENYWRITE // deny write mode
2444	\| OPEN_ACCESS_WRITEONLY, // write mode
2445	NULL))) // no EAs
2446	{
2447	if (!(arc = DosSetFilePtr(hFile,
2448	0L,
2449	FILE_BEGIN,
2450	&ulLocal)))
2451	if (!(arc = DosWrite(hFile,
2452	(PVOID)pszContent,
2453	ulSize,
2454	&ulWritten)))
2455	arc = DosSetFileSize(hFile, ulSize);
2456
2457	DosClose(hFile);
2458	}
2459	} // end if ((pszFile) && (pszContent))
2460
2461	if (pulWritten)
2462	*pulWritten = ulWritten;
2463
2464	return (arc);
2465	}
2466
2467	/*
2468	*@@category: Helpers\Control program helpers\Directory management
2469	* directory helpers (querying, creating, deleting etc.).
2470	*/
2471
2472	/* ******************************************************************
2473	*
2474	* Directory helpers
2475	*
2476	********************************************************************/
2477
2478	/*
2479	*@@ doshQueryDirExist:
2480	* returns TRUE if the given directory
2481	* exists and really is a directory.
2482	*/
2483
2484	BOOL doshQueryDirExist(PCSZ pcszDir)
2485	{
2486	FILESTATUS3 fs3;
2487	APIRET arc;
2488
2489	if (!(arc = DosQueryPathInfo((PSZ)pcszDir,
2490	FIL_STANDARD,
2491	&fs3,
2492	sizeof(fs3))))
2493	// file found:
2494	return ((fs3.attrFile & FILE_DIRECTORY) != 0);
2495	else
2496	return FALSE;
2497	}
2498
2499	/*
2500	*@@ doshCreatePath:
2501	* this creates the specified directory.
2502	* As opposed to DosCreateDir, this
2503	* function can create several directories
2504	* at the same time, if the parent
2505	* directories do not exist yet.
2506	*/
2507
2508	APIRET doshCreatePath(PCSZ pcszPath,
2509	BOOL fHidden) // in: if TRUE, the new directories will get FILE_HIDDEN
2510	{
2511	APIRET arc0 = NO_ERROR;
2512	CHAR path[CCHMAXPATH];
2513	CHAR *cp, c;
2514	ULONG cbPath;
2515
2516	strcpy(path, pcszPath);
2517	cbPath = strlen(path);
2518
2519	if (path[cbPath] != '\\')
2520	{
2521	path[cbPath] = '\\';
2522	path[cbPath+1] = 0;
2523	}
2524
2525	cp = path;
2526	// advance past the drive letter only if we have one
2527	if (*(cp+1) == ':')
2528	cp += 3;
2529
2530	// go!
2531	while (*cp != 0)
2532	{
2533	if (*cp == '\\')
2534	{
2535	c = *cp;
2536	*cp = 0;
2537	if (!doshQueryDirExist(path))
2538	{
2539	APIRET arc = DosCreateDir(path,
2540	0); // no EAs
2541	if (arc != NO_ERROR)
2542	{
2543	arc0 = arc;
2544	break;
2545	}
2546	else
2547	if (fHidden)
2548	{
2549	// hide the directory we just created
2550	doshSetPathAttr(path, FILE_HIDDEN);
2551	}
2552	}
2553	*cp = c;
2554	}
2555	cp++;
2556	}
2557	return (arc0);
2558	}
2559
2560	/*
2561	*@@ doshQueryCurrentDir:
2562	* writes the current directory into
2563	* the specified buffer, which should be
2564	* CCHMAXPATH in size.
2565	*
2566	* As opposed to DosQueryCurrentDir, this
2567	* includes the drive letter.
2568	*
2569	*@@added V0.9.4 (2000-07-22) [umoeller]
2570	*/
2571
2572	APIRET doshQueryCurrentDir(PSZ pszBuf)
2573	{
2574	APIRET arc = NO_ERROR;
2575	ULONG ulCurDisk = 0;
2576	ULONG ulMap = 0;
2577	if (!(arc = DosQueryCurrentDisk(&ulCurDisk, &ulMap)))
2578	{
2579	ULONG cbBuf = CCHMAXPATH - 3;
2580	*pszBuf = ulCurDisk + 'A' - 1;
2581	*(pszBuf + 1) = ':';
2582	*(pszBuf + 2) = '\\';
2583	arc = DosQueryCurrentDir(0, pszBuf + 3, &cbBuf);
2584	}
2585
2586	return (arc);
2587	}
2588
2589	/*
2590	*@@ doshDeleteDir:
2591	* deletes a directory. As opposed to DosDeleteDir,
2592	* this removes empty subdirectories and/or files
2593	* as well.
2594	*
2595	* flFlags can be any combination of the following:
2596	*
2597	* -- DOSHDELDIR_RECURSE: recurse into subdirectories.
2598	*
2599	* -- DOSHDELDIR_DELETEFILES: delete all regular files
2600	* which are found on the way.
2601	*
2602	* THIS IS NOT IMPLEMENTED YET.
2603	*
2604	* If 0 is specified, this effectively behaves just as
2605	* DosDeleteDir.
2606	*
2607	* If you specify DOSHDELDIR_RECURSE only, only empty
2608	* subdirectories are deleted as well.
2609	*
2610	* If you specify DOSHDELDIR_RECURSE \| DOSHDELDIR_DELETEFILES,
2611	* this removes an entire directory tree, including all
2612	* subdirectories and files.
2613	*
2614	*@@added V0.9.4 (2000-07-01) [umoeller]
2615	*/
2616
2617	APIRET doshDeleteDir(PCSZ pcszDir,
2618	ULONG flFlags,
2619	PULONG pulDirs, // out: directories found
2620	PULONG pulFiles) // out: files found
2621	{
2622	APIRET arc = NO_ERROR,
2623	arcReturn = NO_ERROR;
2624
2625	HDIR hdirFindHandle = HDIR_CREATE;
2626	FILEFINDBUF3 ffb3 = {0}; // returned from FindFirst/Next
2627	ULONG ulResultBufLen = sizeof(FILEFINDBUF3);
2628	ULONG ulFindCount = 1; // look for 1 file at a time
2629
2630	CHAR szFileMask[2*CCHMAXPATH];
2631	sprintf(szFileMask, "%s\\*", pcszDir);
2632
2633	// find files
2634	arc = DosFindFirst(szFileMask,
2635	&hdirFindHandle, // directory search handle
2636	FILE_ARCHIVED \| FILE_DIRECTORY \| FILE_SYSTEM
2637	\| FILE_HIDDEN \| FILE_READONLY,
2638	// search attributes; include all, even dirs
2639	&ffb3, // result buffer
2640	ulResultBufLen, // result buffer length
2641	&ulFindCount, // number of entries to find
2642	FIL_STANDARD); // return level 1 file info
2643
2644	if (arc == NO_ERROR)
2645	{
2646	// keep finding the next file until there are no more files
2647	while (arc == NO_ERROR) // != ERROR_NO_MORE_FILES
2648	{
2649	if (ffb3.attrFile & FILE_DIRECTORY)
2650	{
2651	// we found a directory:
2652
2653	// ignore the pseudo-directories
2654	if ( (strcmp(ffb3.achName, ".") != 0)
2655	&& (strcmp(ffb3.achName, "..") != 0)
2656	)
2657	{
2658	// real directory:
2659	if (flFlags & DOSHDELDIR_RECURSE)
2660	{
2661	// recurse!
2662	CHAR szSubDir[2*CCHMAXPATH];
2663	sprintf(szSubDir, "%s\\%s", pcszDir, ffb3.achName);
2664	arcReturn = doshDeleteDir(szSubDir,
2665	flFlags,
2666	pulDirs,
2667	pulFiles);
2668	// this removes ffb3.achName as well
2669	}
2670	else
2671	{
2672	// directory, but no recursion:
2673	// report "access denied"
2674	// (this is what OS/2 reports with DosDeleteDir as well)
2675	arcReturn = ERROR_ACCESS_DENIED; // 5
2676	(*pulDirs)++;
2677	}
2678	}
2679	}
2680	else
2681	{
2682	// it's a file:
2683	arcReturn = ERROR_ACCESS_DENIED;
2684	(*pulFiles)++;
2685	}
2686
2687	if (arc == NO_ERROR)
2688	{
2689	ulFindCount = 1; // reset find count
2690	arc = DosFindNext(hdirFindHandle, // directory handle
2691	&ffb3, // result buffer
2692	ulResultBufLen, // result buffer length
2693	&ulFindCount); // number of entries to find
2694	}
2695	} // endwhile
2696
2697	DosFindClose(hdirFindHandle); // close our find handle
2698	}
2699
2700	if (arcReturn == NO_ERROR)
2701	// success so far:
2702	// delete our directory now
2703	arc = DosDeleteDir((PSZ)pcszDir);
2704
2705	return (arcReturn);
2706	}
2707
2708	/*
2709	*@@category: Helpers\Control program helpers\Module handling
2710	* helpers for importing functions from a module (DLL).
2711	*/
2712
2713	/* ******************************************************************
2714	*
2715	* Module handling helpers
2716	*
2717	********************************************************************/
2718
2719	/*
2720	*@@ doshResolveImports:
2721	* this function loads the module called pszModuleName
2722	* and resolves imports dynamically using DosQueryProcAddress.
2723	*
2724	* To specify the functions to be imported, a RESOLVEFUNCTION
2725	* array is used. In each of the array items, specify the
2726	* name of the function and a pointer to a function pointer
2727	* where to store the resolved address.
2728	*
2729	*@@added V0.9.3 (2000-04-29) [umoeller]
2730	*/
2731
2732	APIRET doshResolveImports(PSZ pszModuleName, // in: DLL to load
2733	HMODULE *phmod, // out: module handle
2734	PRESOLVEFUNCTION paResolves, // in/out: function resolves
2735	ULONG cResolves) // in: array item count (not array size!)
2736	{
2737	CHAR szName[CCHMAXPATH];
2738	APIRET arc;
2739
2740	if (!(arc = DosLoadModule(szName,
2741	sizeof(szName),
2742	pszModuleName,
2743	phmod)))
2744	{
2745	ULONG ul;
2746	for (ul = 0;
2747	ul < cResolves;
2748	ul++)
2749	{
2750	if (arc = DosQueryProcAddr(*phmod,
2751	0, // ordinal, ignored
2752	(PSZ)paResolves[ul].pcszFunctionName,
2753	paResolves[ul].ppFuncAddress))
2754	// error:
2755	break;
2756	}
2757
2758	if (arc)
2759	// V0.9.16 (2001-12-08) [umoeller]
2760	DosFreeModule(*phmod);
2761	}
2762
2763	return (arc);
2764	}
2765
2766	/*
2767	*@@category: Helpers\Control program helpers\Performance (CPU load) helpers
2768	* helpers around DosPerfSysCall.
2769	*/
2770
2771	/* ******************************************************************
2772	*
2773	* Performance Counters (CPU Load)
2774	*
2775	********************************************************************/
2776
2777	/*
2778	*@@ doshPerfOpen:
2779	* initializes the OS/2 DosPerfSysCall API for
2780	* the calling thread.
2781	*
2782	* Note: This API is not supported on all OS/2
2783	* versions. I believe it came up with some Warp 4
2784	* fixpak. The API is resolved dynamically by
2785	* this function (using DosQueryProcAddr). Only
2786	* if NO_ERROR is returned, you may call doshPerfGet
2787	* afterwards.
2788	*
2789	* This properly initializes the internal counters
2790	* which the OS/2 kernel uses for this API. Apparently,
2791	* with newer kernels (FP13/14), IBM has chosen to no
2792	* longer do this automatically, which is the reason
2793	* why many "pulse" utilities display garbage with these
2794	* fixpaks.
2795	*
2796	* After NO_ERROR is returned, DOSHPERFSYS.cProcessors
2797	* contains the no. of processors found on the system.
2798	* All pointers in DOSHPERFSYS then point to arrays
2799	* which have exactly cProcessors array items.
2800	*
2801	* Call doshPerfClose to clean up resources allocated
2802	* by this function.
2803	*
2804	* Example code:
2805	*
2806	+ PDOSHPERFSYS pPerf = NULL;
2807	+ APIRET arc = doshPerfOpen(&pPerf);
2808	+ if (arc == NO_ERROR)
2809	+ {
2810	+ // this should really be in a timer
2811	+ ULONG ulCPU;
2812	+ arc = doshPerfGet(&pPerf);
2813	+ // go thru all CPUs
2814	+ for (ulCPU = 0; ulCPU < pPerf->cProcessors; ulCPU++)
2815	+ {
2816	+ LONG lLoadThis = pPerf->palLoads[ulCPU];
2817	+ ...
2818	+ }
2819	+
2820	+ ...
2821	+
2822	+ // clean up
2823	+ doshPerfClose(&pPerf);
2824	+ }
2825	+
2826	*
2827	*@@added V0.9.7 (2000-12-02) [umoeller]
2828	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
2829	*/
2830
2831	APIRET doshPerfOpen(PDOSHPERFSYS *ppPerfSys) // out: new DOSHPERFSYS structure
2832	{
2833	APIRET arc = NO_ERROR;
2834
2835	// allocate DOSHPERFSYS structure
2836	*ppPerfSys = (PDOSHPERFSYS)malloc(sizeof(DOSHPERFSYS));
2837	if (!*ppPerfSys)
2838	arc = ERROR_NOT_ENOUGH_MEMORY;
2839	else
2840	{
2841	// initialize structure
2842	PDOSHPERFSYS pPerfSys = *ppPerfSys;
2843	memset(pPerfSys, 0, sizeof(*pPerfSys));
2844
2845	// resolve DosPerfSysCall API entry
2846	if (!(arc = DosLoadModule(NULL, 0, "DOSCALLS", &pPerfSys->hmod)))
2847	{
2848	if (!(arc = DosQueryProcAddr(pPerfSys->hmod,
2849	976,
2850	"DosPerfSysCall",
2851	(PFN*)(&pPerfSys->pDosPerfSysCall))))
2852	{
2853	// OK, we got the API: initialize!
2854	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_ENABLE, 0, 0, 0)))
2855	{
2856	pPerfSys->fInitialized = TRUE;
2857	// call CMD_KI_DISABLE later
2858
2859	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_PERF_INFO,
2860	0,
2861	(ULONG)(&pPerfSys->cProcessors),
2862	0)))
2863	{
2864	ULONG ul = 0,
2865	cProcs = pPerfSys->cProcessors,
2866	cbDouble = cProcs * sizeof(double),
2867	cbLong = cProcs * sizeof(LONG);
2868
2869	// allocate arrays
2870	if ( (!(pPerfSys->paCPUUtils = (PCPUUTIL)calloc(cProcs,
2871	sizeof(CPUUTIL))))
2872	\|\| (!(pPerfSys->padBusyPrev
2873	= (double*)malloc(cbDouble)))
2874	\|\| (!(pPerfSys->padTimePrev
2875	= (double*)malloc(cbDouble)))
2876	\|\| (!(pPerfSys->padIntrPrev
2877	= (double*)malloc(cbDouble)))
2878	\|\| (!(pPerfSys->palLoads
2879	= (PLONG)malloc(cbLong)))
2880	\|\| (!(pPerfSys->palIntrs
2881	= (PLONG)malloc(cbLong)))
2882	)
2883	arc = ERROR_NOT_ENOUGH_MEMORY;
2884	else
2885	{
2886	for (ul = 0; ul < cProcs; ul++)
2887	{
2888	pPerfSys->padBusyPrev[ul] = 0.0;
2889	pPerfSys->padTimePrev[ul] = 0.0;
2890	pPerfSys->padIntrPrev[ul] = 0.0;
2891	pPerfSys->palLoads[ul] = 0;
2892	pPerfSys->palIntrs[ul] = 0;
2893	}
2894	}
2895	}
2896	}
2897	} // end if (arc == NO_ERROR)
2898	} // end if (arc == NO_ERROR)
2899
2900	if (arc)
2901	// error: clean up
2902	doshPerfClose(ppPerfSys);
2903
2904	} // end else if (!*ppPerfSys)
2905
2906	return (arc);
2907	}
2908
2909	/*
2910	*@@ doshPerfGet:
2911	* calculates a current snapshot of the system load,
2912	* compared with the load which was calculated on
2913	* the previous call.
2914	*
2915	* If you want to continually measure the system CPU
2916	* load, this is the function you will want to call
2917	* regularly -- e.g. with a timer once per second.
2918	*
2919	* Call this ONLY if doshPerfOpen returned NO_ERROR,
2920	* or you'll get crashes.
2921	*
2922	* If this call returns NO_ERROR, you get LONG load
2923	* values for each CPU in the system in the arrays
2924	* in DOSHPERFSYS (in per-mille, 0-1000).
2925	*
2926	* There are two arrays:
2927	*
2928	* -- DOSHPERFSYS.palLoads contains the "user" load
2929	* for each CPU.
2930	*
2931	* -- DOSHPERFSYS.palIntrs contains the "IRQ" load
2932	* for each CPU.
2933	*
2934	* Sum up the two values to get the total load for
2935	* each CPU.
2936	*
2937	* For example, if there are two CPUs, after this call,
2938	*
2939	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
2940	* of the first CPU,
2941	*
2942	* -- DOSHPERFSYS.palLoads[0] contains the "user" load
2943	* of the second CPU.
2944	*
2945	* See doshPerfOpen for example code.
2946	*
2947	*@@added V0.9.7 (2000-12-02) [umoeller]
2948	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
2949	*/
2950
2951	APIRET doshPerfGet(PDOSHPERFSYS pPerfSys)
2952	{
2953	APIRET arc = NO_ERROR;
2954	if (!pPerfSys->pDosPerfSysCall)
2955	arc = ERROR_INVALID_PARAMETER;
2956	else
2957	{
2958	if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_RDCNT,
2959	(ULONG)pPerfSys->paCPUUtils,
2960	0, 0)))
2961	{
2962	// go thru all processors
2963	ULONG ul = 0;
2964	for (; ul < pPerfSys->cProcessors; ul++)
2965	{
2966	PCPUUTIL pCPUUtilThis = &pPerfSys->paCPUUtils[ul];
2967
2968	double dTime = LL2F(pCPUUtilThis->ulTimeHigh,
2969	pCPUUtilThis->ulTimeLow);
2970	double dBusy = LL2F(pCPUUtilThis->ulBusyHigh,
2971	pCPUUtilThis->ulBusyLow);
2972	double dIntr = LL2F(pCPUUtilThis->ulIntrHigh,
2973	pCPUUtilThis->ulIntrLow);
2974
2975	double *pdBusyPrevThis = &pPerfSys->padBusyPrev[ul];
2976	double *pdTimePrevThis = &pPerfSys->padTimePrev[ul];
2977	double *pdIntrPrevThis = &pPerfSys->padIntrPrev[ul];
2978
2979	// avoid division by zero
2980	double dTimeDelta = (dTime - *pdTimePrevThis);
2981	if (dTimeDelta)
2982	{
2983	pPerfSys->palLoads[ul]
2984	= (LONG)( (double)( (dBusy - *pdBusyPrevThis)
2985	/ dTimeDelta
2986	* 1000.0
2987	)
2988	);
2989	pPerfSys->palIntrs[ul]
2990	= (LONG)( (double)( (dIntr - *pdIntrPrevThis)
2991	/ dTimeDelta
2992	* 1000.0
2993	)
2994	);
2995	}
2996	else
2997	{
2998	// no clear readings are available
2999	pPerfSys->palLoads[ul] = 0;
3000	pPerfSys->palIntrs[ul] = 0;
3001	}
3002
3003	*pdTimePrevThis = dTime;
3004	*pdBusyPrevThis = dBusy;
3005	*pdIntrPrevThis = dIntr;
3006	}
3007	}
3008	}
3009
3010	return (arc);
3011	}
3012
3013	/*
3014	*@@ doshPerfClose:
3015	* frees all resources allocated by doshPerfOpen.
3016	*
3017	*@@added V0.9.7 (2000-12-02) [umoeller]
3018	*@@changed V0.9.9 (2001-02-06) [umoeller]: removed disable; this broke the WarpCenter
3019	*@@changed V0.9.9 (2001-03-14) [umoeller]: fixed memory leak
3020	*@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3021	*/
3022
3023	APIRET doshPerfClose(PDOSHPERFSYS *ppPerfSys)
3024	{
3025	APIRET arc = NO_ERROR;
3026	PDOSHPERFSYS pPerfSys = *ppPerfSys;
3027	if (!pPerfSys)
3028	arc = ERROR_INVALID_PARAMETER;
3029	else
3030	{
3031	// do not call this, this messes up the WarpCenter V0.9.9 (2001-02-06) [umoeller]
3032	// if (pPerfSys->fInitialized) pPerfSys->pDosPerfSysCall(CMD_KI_DISABLE, 0, 0, 0);
3033
3034	if (pPerfSys->paCPUUtils)
3035	free(pPerfSys->paCPUUtils);
3036	if (pPerfSys->padBusyPrev)
3037	free(pPerfSys->padBusyPrev);
3038	if (pPerfSys->padTimePrev)
3039	free(pPerfSys->padTimePrev);
3040	if (pPerfSys->padIntrPrev)
3041	free(pPerfSys->padIntrPrev);
3042	if (pPerfSys->palLoads) // was missing V0.9.9 (2001-03-14) [umoeller]
3043	free(pPerfSys->palLoads);
3044	if (pPerfSys->palIntrs)
3045	free(pPerfSys->palIntrs);
3046
3047	if (pPerfSys->hmod)
3048	DosFreeModule(pPerfSys->hmod);
3049	free(pPerfSys);
3050	*ppPerfSys = NULL;
3051	}
3052
3053	return (arc);
3054	}
3055
3056	/*
3057	*@@category: Helpers\Control program helpers\Process management
3058	* helpers for starting subprocesses.
3059	*/
3060
3061	/* ******************************************************************
3062	*
3063	* Process helpers
3064	*
3065	********************************************************************/
3066
3067	static PVOID // G_pvGlobalInfoSeg = NULL,
3068	G_pvLocalInfoSeg = NULL;
3069
3070	USHORT _Far16 _Pascal Dos16GetInfoSeg(PSEL pselGlobal,
3071	PSEL pselLocal);
3072
3073	/*
3074	* GetInfoSegs:
3075	*
3076	*/
3077
3078	VOID GetInfoSegs(VOID)
3079	{
3080	SEL GlobalInfoSegSelector,
3081	LocalInfoSegSelector;
3082
3083	// get selectors (old 16-bit API; this gets called only once)
3084	Dos16GetInfoSeg(&GlobalInfoSegSelector,
3085	&LocalInfoSegSelector);
3086	// thunk
3087	/* G_pvGlobalInfoSeg = (PVOID)( (GlobalInfoSegSelector << 0x000D)
3088	& 0x01fff0000); */
3089	G_pvLocalInfoSeg = (PVOID)( (LocalInfoSegSelector << 0x000D)
3090	& 0x01fff0000);
3091	}
3092
3093	/*
3094	*@@ doshMyPID:
3095	* returns the PID of the current process.
3096	*
3097	* This uses an interesting hack which is way
3098	* faster than DosGetInfoBlocks.
3099	*
3100	*@@added V0.9.9 (2001-04-04) [umoeller]
3101	*/
3102
3103	ULONG doshMyPID(VOID)
3104	{
3105	if (!G_pvLocalInfoSeg)
3106	// first call:
3107	GetInfoSegs();
3108
3109	// PID is at offset 0 in the local info seg
3110	return (*(PUSHORT)G_pvLocalInfoSeg);
3111	}
3112
3113	/*
3114	*@@ doshMyTID:
3115	* returns the TID of the current thread.
3116	*
3117	* This uses an interesting hack which is way
3118	* faster than DosGetInfoBlocks.
3119	*
3120	*@@added V0.9.9 (2001-04-04) [umoeller]
3121	*/
3122
3123	ULONG doshMyTID(VOID)
3124	{
3125	if (!G_pvLocalInfoSeg)
3126	// first call:
3127	GetInfoSegs();
3128
3129	// TID is at offset 6 in the local info seg
3130	return (*(PUSHORT)((PBYTE)G_pvLocalInfoSeg + 6));
3131	}
3132
3133	/*
3134	*@@ doshExecVIO:
3135	* executes cmd.exe with the /c parameter
3136	* and pcszExecWithArgs. This is equivalent
3137	* to the C library system() function,
3138	* except that an OS/2 error code is returned
3139	* and that this works with the VAC subsystem
3140	* library.
3141	*
3142	* This uses DosExecPgm and handles the sick
3143	* argument passing.
3144	*
3145	* If NO_ERROR is returned, *plExitCode receives
3146	* the exit code of the process. If the process
3147	* was terminated abnormally, *plExitCode receives:
3148	*
3149	* -- -1: hard error halt
3150	* -- -2: 16-bit trap
3151	* -- -3: DosKillProcess
3152	* -- -4: 32-bit exception
3153	*
3154	*@@added V0.9.4 (2000-07-27) [umoeller]
3155	*/
3156
3157	APIRET doshExecVIO(PCSZ pcszExecWithArgs,
3158	PLONG plExitCode) // out: exit code (ptr can be NULL)
3159	{
3160	APIRET arc = NO_ERROR;
3161
3162	if (strlen(pcszExecWithArgs) > 255)
3163	arc = ERROR_INSUFFICIENT_BUFFER;
3164	else
3165	{
3166	CHAR szObj[CCHMAXPATH];
3167	RESULTCODES res = {0};
3168	CHAR szBuffer[300];
3169
3170	// DosExecPgm expects two args in szBuffer:
3171	// -- cmd.exe\0
3172	// -- then the actual argument, terminated by two 0 bytes.
3173	memset(szBuffer, 0, sizeof(szBuffer));
3174	strcpy(szBuffer, "cmd.exe\0");
3175	sprintf(szBuffer + 8, "/c %s",
3176	pcszExecWithArgs);
3177
3178	arc = DosExecPgm(szObj, sizeof(szObj),
3179	EXEC_SYNC,
3180	szBuffer,
3181	0,
3182	&res,
3183	"cmd.exe");
3184	if ((arc == NO_ERROR) && (plExitCode))
3185	{
3186	if (res.codeTerminate == 0)
3187	// normal exit:
3188	*plExitCode = res.codeResult;
3189	else
3190	*plExitCode = -((LONG)res.codeTerminate);
3191	}
3192	}
3193
3194	return (arc);
3195	}
3196
3197	/*
3198	*@@ doshQuickStartSession:
3199	* this is a shortcut to DosStartSession w/out having to
3200	* deal with all the messy parameters.
3201	*
3202	* This one starts pszPath as a child session and passes
3203	* pszParams to it.
3204	*
3205	* In usPgmCtl, OR any or none of the following (V0.9.0):
3206	* -- SSF_CONTROL_NOAUTOCLOSE (0x0008): do not close automatically.
3207	* This bit is used only for VIO Windowable apps and ignored
3208	* for all other applications.
3209	* -- SSF_CONTROL_MINIMIZE (0x0004)
3210	* -- SSF_CONTROL_MAXIMIZE (0x0002)
3211	* -- SSF_CONTROL_INVISIBLE (0x0001)
3212	* -- SSF_CONTROL_VISIBLE (0x0000)
3213	*
3214	* Specifying 0 will therefore auto-close the session and make it
3215	* visible.
3216	*
3217	* If (fWait), this function will create a termination queue
3218	* and not return until the child session has ended. Be warned,
3219	* this blocks the calling thread.
3220	*
3221	* Otherwise the function will return immediately.
3222	*
3223	* The session and process IDs of the child session will be
3224	* written to pulSID and ppid. Of course, in "wait" mode,
3225	* these are no longer valid after this function returns.
3226	*
3227	* Returns the error code of DosStartSession.
3228	*
3229	* Note: According to CPREF, calling DosStartSession calls
3230	* DosExecPgm in turn for all full-screen, VIO, and PM sessions.
3231	*
3232	*@@changed V0.9.0 [umoeller]: prototype changed to include usPgmCtl
3233	*@@changed V0.9.1 (99-12-30) [umoeller]: queue was sometimes not closed. Fixed.
3234	*@@changed V0.9.3 (2000-05-03) [umoeller]: added fForeground
3235	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed potential queue leak
3236	*@@changed V0.9.14 (2001-08-03) [umoeller]: fixed memory leak in wait mode; added pusReturn to prototype
3237	*/
3238
3239	APIRET doshQuickStartSession(PCSZ pcszPath, // in: program to start
3240	PCSZ pcszParams, // in: parameters for program
3241	BOOL fForeground, // in: if TRUE, session will be in foreground
3242	USHORT usPgmCtl, // in: STARTDATA.PgmControl
3243	BOOL fWait, // in: wait for termination?
3244	PULONG pulSID, // out: session ID (req.)
3245	PPID ppid, // out: process ID (req.)
3246	PUSHORT pusReturn) // out: in wait mode, session's return code (ptr can be NULL)
3247	{
3248	APIRET arc = NO_ERROR;
3249	// queue stuff
3250	const char *pcszQueueName = "\\queues\\xwphlpsw.que";
3251	HQUEUE hq = 0;
3252	PID qpid = 0;
3253
3254	if (fWait)
3255	{
3256	if (!(arc = DosCreateQueue(&hq,
3257	QUE_FIFO \| QUE_CONVERT_ADDRESS,
3258	(PSZ)pcszQueueName)))
3259	arc = DosOpenQueue(&qpid, &hq, (PSZ)pcszQueueName);
3260	}
3261
3262	if (!arc) // V0.9.14 (2001-08-03) [umoeller]
3263	{
3264	STARTDATA SData;
3265	CHAR szObjBuf[CCHMAXPATH];
3266
3267	SData.Length = sizeof(STARTDATA);
3268	SData.Related = SSF_RELATED_CHILD; //INDEPENDENT;
3269	SData.FgBg = (fForeground) ? SSF_FGBG_FORE : SSF_FGBG_BACK;
3270	// V0.9.3 (2000-05-03) [umoeller]
3271	SData.TraceOpt = SSF_TRACEOPT_NONE;
3272
3273	SData.PgmTitle = (PSZ)pcszPath; // title for window
3274	SData.PgmName = (PSZ)pcszPath;
3275	SData.PgmInputs = (PSZ)pcszParams;
3276
3277	SData.TermQ = (fWait) ? (PSZ)pcszQueueName : NULL;
3278	SData.Environment = 0;
3279	SData.InheritOpt = SSF_INHERTOPT_PARENT;
3280	SData.SessionType = SSF_TYPE_DEFAULT;
3281	SData.IconFile = 0;
3282	SData.PgmHandle = 0;
3283
3284	SData.PgmControl = usPgmCtl;
3285
3286	SData.InitXPos = 30;
3287	SData.InitYPos = 40;
3288	SData.InitXSize = 200;
3289	SData.InitYSize = 140;
3290	SData.Reserved = 0;
3291	SData.ObjectBuffer = szObjBuf;
3292	SData.ObjectBuffLen = (ULONG)sizeof(szObjBuf);
3293
3294	if ( (!(arc = DosStartSession(&SData, pulSID, ppid)))
3295	&& (fWait)
3296	)
3297	{
3298	// block on the termination queue, which is written
3299	// to when the subprocess ends
3300	REQUESTDATA rqdata;
3301	ULONG cbData = 0;
3302	PULONG pulData = NULL;
3303	BYTE elpri;
3304
3305	rqdata.pid = qpid;
3306	if (!(arc = DosReadQueue(hq, // in: queue handle
3307	&rqdata, // out: pid and ulData
3308	&cbData, // out: size of data returned
3309	(PVOID*)&pulData, // out: data returned
3310	0, // in: remove first element in queue
3311	0, // in: wait for queue data (block thread)
3312	&elpri, // out: element's priority
3313	0))) // in: event semaphore to be posted
3314	{
3315	if (!rqdata.ulData)
3316	{
3317	// child session ended:
3318	// V0.9.14 (2001-08-03) [umoeller]
3319
3320	// pulSID = (pulData) & 0xffff;
3321	if (pusReturn)
3322	pusReturn = ((pulData) >> 16) & 0xffff;
3323
3324	}
3325	// else: continue looping
3326
3327	if (pulData)
3328	DosFreeMem(pulData);
3329	}
3330	}
3331	}
3332
3333	if (hq)
3334	DosCloseQueue(hq);
3335
3336	return (arc);
3337	}
3338
3339

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

Download in other formats: