Context Navigation

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

Visit:

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

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

Download in other formats: