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

Last change on this file since 362 was 353, checked in by pr, 18 years ago

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