source: branches/branch-1-0/src/helpers/dosh.c@ 231

Last change on this file since 231 was 229, checked in by umoeller, 23 years ago

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