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

Last change on this file since 127 was 127, checked in by umoeller, 24 years ago

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