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

Last change on this file was 413, checked in by pr, 13 years ago

Fix buffer overwrite. Bug 1206.
  • Property svn:eol-style set to CRLF
  • Property svn:keywords set to Author Date Id Revision
File size: 141.8 KB
Line 
1
2/*
3 *@@sourcefile dosh.c:
4 * dosh.c contains Control Program helper functions.
5 *
6 * This file has miscellaneous system functions,
7 * drive helpers, file helpers, and partition functions.
8 *
9 * Usage: All OS/2 programs.
10 *
11 * Function prefixes (new with V0.81):
12 * -- dosh* Dos (Control Program) helper functions
13 *
14 * These funcs are forward-declared in dosh.h, which
15 * must be #include'd first.
16 *
17 * The resulting dosh.obj object file can be linked
18 * against any application object file. As opposed to
19 * the code in dosh2.c, it does not require any other
20 * code from the helpers.
21 *
22 * dosh.obj can also be used with the VAC subsystem
23 * library (/rn compiler option).
24 *
25 * Note: Version numbering in this file relates to XWorkplace version
26 * numbering.
27 *
28 *@@header "helpers\dosh.h"
29 */
30
31/*
32 * This file Copyright (C) 1997-2012 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 *@@changed V1.0.10 (2012-06-14) [pr]: fix buffer overwrite @@fixes 1206
1802 */
1803
1804APIRET doshQueryDiskFSType(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1805 PSZ pszBuf, // out: buffer for FS type
1806 ULONG cbBuf) // in: size of that buffer
1807{
1808 APIRET arc = NO_ERROR;
1809 CHAR szName[5];
1810
1811 BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
1812 ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
1813 PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
1814
1815 // compose "D:"-type string from logical drive letter
1816 if (ulLogicalDrive > 0 && ulLogicalDrive < 27)
1817 {
1818 szName[0] = ulLogicalDrive + 'A' - 1;
1819 szName[1] = ':';
1820 szName[2] = '\0';
1821
1822 arc = DosQueryFSAttach(szName, // logical drive of attached FS ("D:"-style)
1823 0, // ulOrdinal, ignored for FSAIL_QUERYNAME
1824 FSAIL_QUERYNAME, // return name for a drive or device
1825 pfsqBuffer, // buffer for returned data
1826 &cbBuffer); // sizeof(*pfsqBuffer)
1827
1828 if (arc == NO_ERROR)
1829 {
1830 if (pszBuf && cbBuf)
1831 {
1832 // The data for the last three fields in the FSQBUFFER2
1833 // structure are stored at the offset of fsqBuffer.szName.
1834 // Each data field following fsqBuffer.szName begins
1835 // immediately after the previous item.
1836 strncpy(pszBuf,
1837 (CHAR*)(&pfsqBuffer->szName) + pfsqBuffer->cbName + 1,
1838 cbBuf); // V0.9.14 (2001-08-01) [umoeller]
1839 *(pszBuf + cbBuf - 1) = '\0';
1840 }
1841 }
1842 }
1843 else
1844 arc = ERROR_INVALID_PARAMETER; // V0.9.16 (2001-10-02) [umoeller]
1845
1846 return arc;
1847}
1848
1849/*
1850 *@@ doshQueryDiskLabel:
1851 * this returns the label of a disk into
1852 * *pszVolumeLabel, which must be 12 bytes
1853 * in size.
1854 *
1855 * This function was added because the Toolkit
1856 * information for DosQueryFSInfo is only partly
1857 * correct. On OS/2 2.x, that function does not
1858 * take an FSINFO structure as input, but a VOLUMELABEL.
1859 * On Warp, this does take an FSINFO.
1860 *
1861 * DosSetFSInfo is even worse. See doshSetDiskLabel.
1862 *
1863 * See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
1864 * for details.
1865 *
1866 *@@added V0.9.0 [umoeller]
1867 *@@changed V0.9.11 (2001-04-22) [umoeller]: this copied even with errors, fixed
1868 */
1869
1870APIRET doshQueryDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1871 PSZ pszVolumeLabel) // out: volume label (must be 12 chars in size)
1872{
1873 APIRET arc;
1874
1875 #ifdef __OS2V2X__
1876 VOLUMELABEL FSInfoBuf;
1877 #else
1878 FSINFO FSInfoBuf;
1879 #endif
1880
1881 arc = DosQueryFSInfo(ulLogicalDrive,
1882 FSIL_VOLSER,
1883 &FSInfoBuf,
1884 sizeof(FSInfoBuf)); // depends
1885
1886 if (!arc) // V0.9.11 (2001-04-22) [umoeller]
1887 {
1888 #ifdef __OS2V2X__
1889 strcpy(pszVolumeLabel, FSInfoBuf.szVolLabel);
1890 #else
1891 strcpy(pszVolumeLabel, FSInfoBuf.vol.szVolLabel);
1892 #endif
1893 }
1894
1895 return arc;
1896}
1897
1898/*
1899 *@@ doshSetDiskLabel:
1900 * this sets the label of a disk.
1901 *
1902 * This function was added because the Toolkit
1903 * information for DosSetFSInfo is flat out wrong.
1904 * That function does not take an FSINFO structure
1905 * as input, but a VOLUMELABEL. As a result, using
1906 * that function with the Toolkit's calling specs
1907 * results in ERROR_LABEL_TOO_LONG always.
1908 *
1909 * See http://zebra.asta.fh-weingarten.de/os2/Snippets/Bugi6787.HTML
1910 * for details.
1911 *
1912 *@@added V0.9.0 [umoeller]
1913 */
1914
1915APIRET doshSetDiskLabel(ULONG ulLogicalDrive, // in: 1 for A:, 2 for B:, 3 for C:, ...
1916 PSZ pszNewLabel)
1917{
1918 VOLUMELABEL FSInfoBuf;
1919
1920 // check length; 11 chars plus null byte allowed
1921 FSInfoBuf.cch = (BYTE)strlen(pszNewLabel);
1922 if (FSInfoBuf.cch < sizeof(FSInfoBuf.szVolLabel))
1923 {
1924 strcpy(FSInfoBuf.szVolLabel, pszNewLabel);
1925
1926 return (DosSetFSInfo(ulLogicalDrive,
1927 FSIL_VOLSER,
1928 &FSInfoBuf,
1929 sizeof(FSInfoBuf)));
1930 }
1931 else
1932 return (ERROR_LABEL_TOO_LONG);
1933}
1934
1935/*
1936 *@@category: Helpers\Control program helpers\File name parsing
1937 */
1938
1939/* ******************************************************************
1940 *
1941 * File name parsing
1942 *
1943 ********************************************************************/
1944
1945/*
1946 *@@ doshGetDriveSpec:
1947 * returns the drive specification in pcszFullFile,
1948 * if any is present. This is useful for UNC support.
1949 *
1950 * This returns:
1951 *
1952 * -- NO_ERROR: drive spec was given, and the output
1953 * fields have been set.
1954 *
1955 * -- ERROR_INVALID_NAME: incorrect UNC syntax.
1956 *
1957 * -- ERROR_INVALID_DRIVE: second char is ':', but
1958 * drive letter is not in the range [A-Z].
1959 *
1960 * -- ERROR_INVALID_PARAMETER: no drive spec given
1961 * at all; apparently pcszFullFile is not fully
1962 * qualified in the first place, or it is NULL,
1963 * or its length is <= 2.
1964 *
1965 *@@added V0.9.16 (2001-10-25) [umoeller]
1966 */
1967
1968APIRET doshGetDriveSpec(PCSZ pcszFullFile, // in: fully q'fied file spec
1969 PSZ pszDrive, // out: drive spec ("C:" or "\\SERVER\RESOURCE"; ptr can be NULL)
1970 PULONG pulDriveLen, // out: length of drive spec (2 if local drive; ptr can be NULL)
1971 PBOOL pfIsUNC) // out: set to TRUE if UNC name, FALSE otherwise (ptr can be NULL)
1972{
1973 APIRET arc = NO_ERROR;
1974 ULONG ulFileSpecLength;
1975
1976 if ( (pcszFullFile)
1977 && (ulFileSpecLength = strlen(pcszFullFile))
1978 && (ulFileSpecLength >= 2)
1979 )
1980 {
1981 // upper-case the drive letter
1982 if (pcszFullFile[1] == ':')
1983 {
1984 CHAR cDrive = toupper(*pcszFullFile);
1985 // local drive specified:
1986 if ( (cDrive >= 'A')
1987 && (cDrive <= 'Z')
1988 )
1989 {
1990 if (pszDrive)
1991 {
1992 pszDrive[0] = cDrive;
1993 pszDrive[1] = ':';
1994 pszDrive[2] = '\0';
1995 }
1996
1997 if (pulDriveLen)
1998 *pulDriveLen = 2;
1999 if (pfIsUNC)
2000 *pfIsUNC = FALSE;
2001 }
2002 else
2003 // this is not a valid drive:
2004 arc = ERROR_INVALID_DRIVE;
2005 }
2006 else if ( (pcszFullFile[0] == '\\')
2007 && (pcszFullFile[1] == '\\')
2008 )
2009 {
2010 // UNC drive specified:
2011 // this better be a full \\SERVER\RESOURCE string
2012 PCSZ pResource;
2013 if (pResource = strchr(pcszFullFile + 3, '\\'))
2014 {
2015 // we got at least \\SERVER\:
2016 ULONG ulLength;
2017 PCSZ p;
2018
2019 // check if more stuff is coming
2020 if (p = strchr(pResource + 1, '\\'))
2021 {
2022 // yes: copy server and resource excluding that backslash
2023 if (p == pResource + 1)
2024 // "\\SERVER\\" is invalid
2025 arc = ERROR_INVALID_NAME;
2026 else
2027 // we got "\\SERVER\something\":
2028 // drop the last backslash
2029 ulLength = p - pcszFullFile;
2030 }
2031 else
2032 // "\\SERVER\something" only:
2033 ulLength = ulFileSpecLength;
2034
2035 if (!arc)
2036 {
2037 if (pszDrive)
2038 {
2039 memcpy(pszDrive,
2040 pcszFullFile,
2041 ulLength);
2042 pszDrive[ulLength] = '\0';
2043 }
2044
2045 if (pulDriveLen)
2046 *pulDriveLen = ulLength;
2047 if (pfIsUNC)
2048 *pfIsUNC = TRUE;
2049 }
2050 }
2051 else
2052 // invalid UNC name:
2053 arc = ERROR_INVALID_NAME;
2054 }
2055 else
2056 // neither local, nor UNC:
2057 arc = ERROR_INVALID_PARAMETER;
2058 }
2059 else
2060 arc = ERROR_INVALID_PARAMETER;
2061
2062 return arc;
2063}
2064
2065/*
2066 *@@ doshGetExtension:
2067 * finds the file name extension of pszFilename,
2068 * which can be a file name only or a fully
2069 * qualified filename.
2070 *
2071 * This returns a pointer into pszFilename to
2072 * the character after the last dot.
2073 *
2074 * Returns NULL if not found (e.g. if the filename
2075 * has no dot in it).
2076 *
2077 * In the pathological case of a dot in the path
2078 * but not in the filename itself (e.g.
2079 * "C:\files.new\readme"), this correctly returns
2080 * NULL.
2081 *
2082 *@@added V0.9.6 (2000-10-16) [umoeller]
2083 *@@changed V0.9.7 (2000-12-10) [umoeller]: fixed "F:filename.ext" case
2084 */
2085
2086PSZ doshGetExtension(PCSZ pcszFilename)
2087{
2088 PSZ pReturn = NULL;
2089
2090 if (pcszFilename)
2091 {
2092 // find filename
2093 PCSZ p2,
2094 pStartOfName = NULL,
2095 pExtension = NULL;
2096
2097 if (p2 = strrchr(pcszFilename + 2, '\\'))
2098 // works on "C:\blah" or "\\unc\blah"
2099 pStartOfName = p2 + 1;
2100 else
2101 {
2102 // no backslash found:
2103 // maybe only a drive letter was specified:
2104 if (pcszFilename[1] == ':')
2105 // yes:
2106 pStartOfName = pcszFilename + 2;
2107 else
2108 // then this is not qualified at all...
2109 // use start of filename
2110 pStartOfName = (PSZ)pcszFilename;
2111 }
2112
2113 // find last dot in filename
2114 if (pExtension = strrchr(pStartOfName, '.'))
2115 pReturn = (PSZ)pExtension + 1;
2116 }
2117
2118 return (pReturn);
2119}
2120
2121/*
2122 *@@category: Helpers\Control program helpers\File management
2123 */
2124
2125/* ******************************************************************
2126 *
2127 * File helpers
2128 *
2129 ********************************************************************/
2130
2131/*
2132 *@@ doshIsFileOnFAT:
2133 * returns TRUE if pszFileName resides on
2134 * a FAT drive. Note that pszFileName must
2135 * be fully qualified (i.e. the drive letter
2136 * must be the first character), or this will
2137 * return garbage.
2138 *
2139 *@@changed WarpIN V1.0.20 (2010-06-05) [pr]: now compares FSD name correctly
2140 */
2141
2142BOOL doshIsFileOnFAT(const char* pcszFileName)
2143{
2144 BOOL brc = FALSE;
2145 CHAR szName[5];
2146
2147 APIRET arc;
2148 BYTE fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
2149 ULONG cbBuffer = sizeof(fsqBuffer); // Buffer length)
2150 PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)fsqBuffer;
2151
2152 szName[0] = pcszFileName[0]; // copy drive letter
2153 szName[1] = ':';
2154 szName[2] = '\0';
2155
2156 if (!(arc = DosQueryFSAttach(szName, // logical drive of attached FS
2157 0, // ulOrdinal, ignored for FSAIL_QUERYNAME
2158 FSAIL_QUERYNAME, // return data for a Drive or Device
2159 pfsqBuffer, // returned data
2160 &cbBuffer))) // returned data length
2161 {
2162 // The data for the last three fields in the FSQBUFFER2
2163 // structure are stored at the offset of fsqBuffer.szName.
2164 // Each data field following fsqBuffer.szName begins
2165 // immediately after the previous item.
2166 if (!strncmp(pfsqBuffer->szName + pfsqBuffer->cbName + 1,
2167 "FAT",
2168 pfsqBuffer->cbFSDName))
2169 brc = TRUE;
2170 }
2171
2172 return brc;
2173}
2174
2175/*
2176 *@@ doshQueryFileSize:
2177 * returns the size of an already opened file
2178 * or 0 upon errors.
2179 * Use doshQueryPathSize to query the size of
2180 * any file.
2181 *
2182 *@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
2183 */
2184
2185APIRET doshQueryFileSize(HFILE hFile, // in: file handle
2186 PULONG pulSize) // out: file size (ptr can be NULL)
2187{
2188 APIRET arc;
2189 FILESTATUS3 fs3;
2190 if (!(arc = DosQueryFileInfo(hFile, FIL_STANDARD, &fs3, sizeof(fs3))))
2191 if (pulSize)
2192 *pulSize = fs3.cbFile;
2193 return arc;
2194}
2195
2196/*
2197 *@@ doshQueryPathSize:
2198 * returns the size of any file,
2199 * or 0 if the file could not be
2200 * found.
2201 *
2202 * Use doshQueryFileSize instead to query the
2203 * size if you have a HFILE.
2204 *
2205 * Otherwise this returns:
2206 *
2207 * -- ERROR_FILE_NOT_FOUND
2208 * -- ERROR_PATH_NOT_FOUND
2209 * -- ERROR_SHARING_VIOLATION
2210 * -- ERROR_FILENAME_EXCED_RANGE
2211 * -- ERROR_INVALID_PARAMETER
2212 *
2213 *@@changed V0.9.16 (2001-10-19) [umoeller]: now returning APIRET
2214 */
2215
2216APIRET doshQueryPathSize(PCSZ pcszFile, // in: filename
2217 PULONG pulSize) // out: file size (ptr can be NULL)
2218{
2219 APIRET arc;
2220
2221 if (pcszFile) // V0.9.16 (2001-12-08) [umoeller]
2222 {
2223 FILESTATUS3 fs3;
2224 if (!(arc = DosQueryPathInfo((PSZ)pcszFile, FIL_STANDARD, &fs3, sizeof(fs3))))
2225 if (pulSize)
2226 *pulSize = fs3.cbFile;
2227 }
2228 else
2229 arc = ERROR_INVALID_PARAMETER;
2230
2231 return arc;
2232}
2233
2234/*
2235 *@@ doshQueryPathAttr:
2236 * returns the file attributes of pszFile,
2237 * which can be fully qualified. The
2238 * attributes will be stored in *pulAttr.
2239 * pszFile can also specify a directory,
2240 * although not all attributes make sense
2241 * for directories.
2242 *
2243 * fAttr can be:
2244 * -- FILE_ARCHIVED
2245 * -- FILE_READONLY
2246 * -- FILE_SYSTEM
2247 * -- FILE_HIDDEN
2248 *
2249 * This returns the APIRET of DosQueryPathInfo.
2250 * *pulAttr is only valid if NO_ERROR is
2251 * returned.
2252 *
2253 * Otherwise this returns:
2254 *
2255 * -- ERROR_FILE_NOT_FOUND
2256 * -- ERROR_PATH_NOT_FOUND
2257 * -- ERROR_SHARING_VIOLATION
2258 * -- ERROR_FILENAME_EXCED_RANGE
2259 *
2260 *@@added V0.9.0 [umoeller]
2261 */
2262
2263APIRET doshQueryPathAttr(const char* pcszFile, // in: file or directory name
2264 PULONG pulAttr) // out: attributes (ptr can be NULL)
2265{
2266 FILESTATUS3 fs3;
2267 APIRET arc;
2268
2269 if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
2270 FIL_STANDARD,
2271 &fs3,
2272 sizeof(fs3))))
2273 {
2274 if (pulAttr)
2275 *pulAttr = fs3.attrFile;
2276 }
2277
2278 return arc;
2279}
2280
2281/*
2282 *@@ doshSetPathAttr:
2283 * sets the file attributes of pszFile,
2284 * which can be fully qualified.
2285 * pszFile can also specify a directory,
2286 * although not all attributes make sense
2287 * for directories.
2288 *
2289 * fAttr can be:
2290 * -- FILE_ARCHIVED
2291 * -- FILE_READONLY
2292 * -- FILE_SYSTEM
2293 * -- FILE_HIDDEN
2294 *
2295 * Note that this simply sets all the given
2296 * attributes; the existing attributes
2297 * are lost.
2298 *
2299 * This returns the APIRET of DosQueryPathInfo.
2300 */
2301
2302APIRET doshSetPathAttr(const char* pcszFile, // in: file or directory name
2303 ULONG ulAttr) // in: new attributes
2304{
2305 APIRET arc;
2306
2307 if (pcszFile)
2308 {
2309 FILESTATUS3 fs3;
2310 if (!(arc = DosQueryPathInfo((PSZ)pcszFile,
2311 FIL_STANDARD,
2312 &fs3,
2313 sizeof(fs3))))
2314 {
2315 fs3.attrFile = ulAttr;
2316 arc = DosSetPathInfo((PSZ)pcszFile,
2317 FIL_STANDARD,
2318 &fs3,
2319 sizeof(fs3),
2320 DSPI_WRTTHRU);
2321 }
2322 }
2323 else
2324 arc = ERROR_INVALID_PARAMETER;
2325
2326 return arc;
2327}
2328
2329/*
2330 *@@category: Helpers\Control program helpers\File management\XFILEs
2331 */
2332
2333/* ******************************************************************
2334 *
2335 * XFILEs
2336 *
2337 ********************************************************************/
2338
2339/*
2340 * doshOpen:
2341 * wrapper around DosOpen for simpler opening
2342 * of files.
2343 *
2344 * ulOpenMode determines the mode to open the
2345 * file in (fptr specifies the position after
2346 * the open):
2347 *
2348 + +-------------------------+------+------------+-----------+
2349 + | ulOpenMode | mode | if exists | if new |
2350 + +-------------------------+------+------------+-----------+
2351 + | XOPEN_READ_EXISTING | read | opens | fails |
2352 + | | | fptr = 0 | |
2353 + +-------------------------+------+------------+-----------+
2354 + | XOPEN_READWRITE_EXISTING r/w | opens | fails |
2355 + | | | fptr = 0 | |
2356 + +-------------------------+------+------------+-----------+
2357 + | XOPEN_READWRITE_APPEND | r/w | opens, | creates |
2358 + | | | appends | |
2359 + | | | fptr = end | fptr = 0 |
2360 + +-------------------------+------+------------+-----------+
2361 + | XOPEN_READWRITE_NEW | r/w | replaces | creates |
2362 + | | | fptr = 0 | fptr = 0 |
2363 + +-------------------------+------+------------+-----------+
2364 *
2365 * In addition, you can OR one of the above values with
2366 * the XOPEN_BINARY flag:
2367 *
2368 * -- If XOPEN_BINARY is set, no conversion is performed
2369 * on read and write.
2370 *
2371 * -- If XOPEN_BINARY is _not_ set, all \n chars are
2372 * converted to \r\n on write.
2373 *
2374 * *ppFile receives a new XFILE structure describing
2375 * the open file, if NO_ERROR is returned.
2376 *
2377 * The file pointer is then set to the beginning of the
2378 * file _unless_ XOPEN_READWRITE_APPEND was specified;
2379 * in that case only, the file pointer is set to the
2380 * end of the file so data can be appended (see above).
2381 *
2382 * Otherwise this returns:
2383 *
2384 * -- ERROR_FILE_NOT_FOUND
2385 * -- ERROR_PATH_NOT_FOUND
2386 * -- ERROR_SHARING_VIOLATION
2387 * -- ERROR_FILENAME_EXCED_RANGE
2388 *
2389 * -- ERROR_NOT_ENOUGH_MEMORY
2390 * -- ERROR_INVALID_PARAMETER
2391 *
2392 *@@added V0.9.16 (2001-10-19) [umoeller]
2393 *@@changed V0.9.16 (2001-12-18) [umoeller]: fixed error codes
2394 */
2395
2396APIRET doshOpen(PCSZ pcszFilename, // in: filename to open
2397 ULONG flOpenMode, // in: XOPEN_* mode
2398 PULONG pcbFile, // in: new file size (if new file is created)
2399 // out: file size
2400 PXFILE *ppFile)
2401{
2402 APIRET arc = NO_ERROR;
2403
2404 ULONG fsOpenFlags = 0,
2405 fsOpenMode = OPEN_FLAGS_FAIL_ON_ERROR
2406 | OPEN_FLAGS_NO_LOCALITY
2407 | OPEN_FLAGS_NOINHERIT;
2408
2409 switch (flOpenMode & XOPEN_ACCESS_MASK)
2410 {
2411 case XOPEN_READ_EXISTING:
2412 fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
2413 | OPEN_ACTION_OPEN_IF_EXISTS;
2414 fsOpenMode |= OPEN_SHARE_DENYWRITE
2415 | OPEN_ACCESS_READONLY;
2416
2417 // run this first, because if the file doesn't
2418 // exists, DosOpen only returns ERROR_OPEN_FAILED,
2419 // which isn't that meaningful
2420 // V0.9.16 (2001-12-08) [umoeller]
2421 arc = doshQueryPathSize(pcszFilename,
2422 pcbFile);
2423 break;
2424
2425 case XOPEN_READWRITE_EXISTING:
2426 fsOpenFlags = OPEN_ACTION_FAIL_IF_NEW
2427 | OPEN_ACTION_OPEN_IF_EXISTS;
2428 fsOpenMode |= OPEN_SHARE_DENYWRITE
2429 | OPEN_ACCESS_READWRITE;
2430
2431 arc = doshQueryPathSize(pcszFilename,
2432 pcbFile);
2433 break;
2434
2435 case XOPEN_READWRITE_APPEND:
2436 fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
2437 | OPEN_ACTION_OPEN_IF_EXISTS;
2438 fsOpenMode |= OPEN_SHARE_DENYREADWRITE
2439 | OPEN_ACCESS_READWRITE;
2440 // _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_APPEND"));
2441 break;
2442
2443 case XOPEN_READWRITE_NEW:
2444 fsOpenFlags = OPEN_ACTION_CREATE_IF_NEW
2445 | OPEN_ACTION_REPLACE_IF_EXISTS;
2446 fsOpenMode |= OPEN_SHARE_DENYREADWRITE
2447 | OPEN_ACCESS_READWRITE;
2448 // _Pmpf((__FUNCTION__ ": opening XOPEN_READWRITE_NEW"));
2449 break;
2450 }
2451
2452 if ((!arc) && fsOpenFlags && pcbFile && ppFile)
2453 {
2454 PXFILE pFile;
2455 if (pFile = NEW(XFILE))
2456 {
2457 ULONG ulAction;
2458
2459 ZERO(pFile);
2460
2461 // copy open flags
2462 pFile->flOpenMode = flOpenMode;
2463
2464 if (!(arc = DosOpen((PSZ)pcszFilename,
2465 &pFile->hf,
2466 &ulAction,
2467 *pcbFile,
2468 FILE_ARCHIVED,
2469 fsOpenFlags,
2470 fsOpenMode,
2471 NULL))) // EAs
2472 {
2473 // alright, got the file:
2474
2475 if ( (ulAction == FILE_EXISTED)
2476 && ((flOpenMode & XOPEN_ACCESS_MASK) == XOPEN_READWRITE_APPEND)
2477 )
2478 // get its size and set ptr to end for append
2479 arc = DosSetFilePtr(pFile->hf,
2480 0,
2481 FILE_END,
2482 pcbFile);
2483 else
2484 arc = doshQueryFileSize(pFile->hf,
2485 pcbFile);
2486 // file ptr is at beginning
2487
2488 #ifdef DEBUG_DOSOPEN
2489 if (arc)
2490 _Pmpf((__FUNCTION__ ": DosSetFilePtr/queryfilesize returned %d for %s",
2491 arc, pcszFilename));
2492 #endif
2493
2494 // store file size
2495 pFile->cbInitial
2496 = pFile->cbCurrent
2497 = *pcbFile;
2498
2499 pFile->pszFilename = strdup(pcszFilename);
2500 }
2501 #ifdef DEBUG_DOSOPEN
2502 else
2503 _Pmpf((__FUNCTION__ ": DosOpen returned %d for %s",
2504 arc, pcszFilename));
2505 #endif
2506
2507 if (arc)
2508 doshClose(&pFile);
2509 else
2510 *ppFile = pFile;
2511 }
2512 else
2513 arc = ERROR_NOT_ENOUGH_MEMORY;
2514 }
2515 else
2516 if (!arc) // V0.9.19 (2002-04-02) [umoeller]
2517 arc = ERROR_INVALID_PARAMETER;
2518
2519 return arc;
2520}
2521
2522/*
2523 *@@ doshReadAt:
2524 * reads cb bytes from the position specified by
2525 * lOffset into the buffer pointed to by pbData,
2526 * which should be cb bytes in size.
2527 *
2528 * Note that lOffset is always considered to
2529 * be from the beginning of the file (FILE_BEGIN
2530 * method).
2531 *
2532 * This implements a small cache so that several
2533 * calls with a near offset will not touch the
2534 * disk always. The cache has been optimized for
2535 * the exeh* functions and works quite nicely
2536 * there.
2537 *
2538 * Note that the position of the file pointer is
2539 * undefined after calling this function because
2540 * the data might have been returned from the
2541 * cache.
2542 *
2543 * fl may be any combination of the following:
2544 *
2545 * -- DRFL_NOCACHE: do not fill the cache with
2546 * new data if the data is not in the cache
2547 * currently.
2548 *
2549 * -- DRFL_FAILIFLESS: return ERROR_NO_DATA
2550 * if the data returned by DosRead is less
2551 * than what was specified. This might
2552 * simplify error handling.
2553 *
2554 *@@added V0.9.13 (2001-06-14) [umoeller]
2555 *@@changed V0.9.16 (2001-12-18) [umoeller]: now with XFILE, and always using FILE_BEGIN
2556 *@@chaanged V0.9.19 (2002-04-02) [umoeller]: added params checking
2557 */
2558
2559APIRET doshReadAt(PXFILE pFile,
2560 ULONG ulOffset, // in: offset to read from (from beginning of file)
2561 PULONG pcb, // in: bytes to read, out: bytes read (req.)
2562 PBYTE pbData, // out: read buffer (must be cb bytes)
2563 ULONG fl) // in: DRFL_* flags
2564{
2565 APIRET arc = NO_ERROR;
2566 ULONG cb;
2567 ULONG ulDummy;
2568
2569 if (!pFile || !pcb)
2570 // V0.9.19 (2002-04-02) [umoeller]
2571 return ERROR_INVALID_PARAMETER;
2572
2573 cb = *pcb;
2574 *pcb = 0;
2575
2576 // check if we have the data in the cache already;
2577
2578 if ( (pFile->pbCache)
2579 // first byte must be in cache
2580 && (ulOffset >= pFile->ulReadFrom)
2581 // last byte must be in cache
2582 && ( ulOffset + cb
2583 <= pFile->ulReadFrom + pFile->cbCache
2584 )
2585 )
2586 {
2587 // alright, return data from cache simply
2588 ULONG ulOfsInCache = ulOffset - pFile->ulReadFrom;
2589
2590 memcpy(pbData,
2591 pFile->pbCache + ulOfsInCache,
2592 cb);
2593 *pcb = cb;
2594
2595 #ifdef DEBUG_DOSOPEN
2596 _Pmpf((__FUNCTION__ " %s: data is fully in cache",
2597 pFile->pszFilename));
2598 _Pmpf((" caller wants %d bytes from %d",
2599 cb, ulOffset));
2600 _Pmpf((" we got %d bytes from %d",
2601 pFile->cbCache, pFile->ulReadFrom));
2602 _Pmpf((" so copied %d bytes from cache ofs %d",
2603 cb, ulOfsInCache));
2604 #endif
2605 }
2606 else
2607 {
2608 // data is not in cache:
2609 // check how much it is... for small amounts,
2610 // we load the cache first
2611 if ( (cb <= 4096 - 512)
2612 && (!(fl & DRFL_NOCACHE))
2613 )
2614 {
2615 #ifdef DEBUG_DOSOPEN
2616 _Pmpf((__FUNCTION__ " %s: filling cache anew",
2617 pFile->pszFilename));
2618 _Pmpf((" caller wants %d bytes from %d",
2619 cb, ulOffset));
2620 #endif
2621
2622 // OK, then fix the offset to read from
2623 // to a multiple of 512 to get a full sector
2624 pFile->ulReadFrom = ulOffset / 512L * 512L;
2625 // and read 4096 bytes always plus the
2626 // value we cut off above
2627 pFile->cbCache = 4096;
2628
2629 #ifdef DEBUG_DOSOPEN
2630 _Pmpf((" getting %d bytes from %d",
2631 pFile->cbCache, pFile->ulReadFrom));
2632 #endif
2633
2634 // free old cache
2635 if (pFile->pbCache)
2636 free(pFile->pbCache);
2637
2638 // allocate new cache
2639 if (!(pFile->pbCache = (PBYTE)malloc(pFile->cbCache)))
2640 arc = ERROR_NOT_ENOUGH_MEMORY;
2641 else
2642 {
2643 ULONG ulOfsInCache = 0;
2644
2645 if (!(arc = DosSetFilePtr(pFile->hf,
2646 (LONG)pFile->ulReadFrom,
2647 FILE_BEGIN,
2648 &ulDummy)))
2649 {
2650 if (!(arc = DosRead(pFile->hf,
2651 pFile->pbCache,
2652 pFile->cbCache,
2653 &ulDummy)))
2654 {
2655 // got data:
2656 #ifdef DEBUG_DOSOPEN
2657 _Pmpf((" %d bytes read", ulDummy));
2658 #endif
2659
2660 pFile->cbCache = ulDummy;
2661
2662 // check bounds
2663 ulOfsInCache = ulOffset - pFile->ulReadFrom;
2664
2665 /*
2666 if (ulOfsInCache + cb > pFile->cbCache)
2667 {
2668 cb = pFile->cbCache - ulOfsInCache;
2669 if (fl & DRFL_FAILIFLESS)
2670 arc = ERROR_NO_DATA;
2671 }
2672 */
2673 }
2674 }
2675
2676 if (!arc)
2677 {
2678 // copy to caller
2679 memcpy(pbData,
2680 pFile->pbCache + ulOfsInCache,
2681 cb);
2682 *pcb = cb;
2683
2684 #ifdef DEBUG_DOSOPEN
2685 _Pmpf((" so copied %d bytes from cache ofs %d",
2686 cb, ulOfsInCache));
2687 #endif
2688 }
2689 else
2690 {
2691 free(pFile->pbCache);
2692 pFile->pbCache = NULL;
2693 }
2694 } // end else if (!(pFile->pbCache = (PBYTE)malloc(pFile->cbCache)))
2695 }
2696 else
2697 {
2698 // read uncached:
2699 #ifdef DEBUG_DOSOPEN
2700 _Pmpf((" " __FUNCTION__ " %s: reading uncached",
2701 pFile->pszFilename));
2702 _Pmpf((" caller wants %d bytes from %d",
2703 cb, ulOffset));
2704 #endif
2705
2706 if (!(arc = DosSetFilePtr(pFile->hf,
2707 (LONG)ulOffset,
2708 FILE_BEGIN,
2709 &ulDummy)))
2710 {
2711 if (!(arc = DosRead(pFile->hf,
2712 pbData,
2713 cb,
2714 &ulDummy)))
2715 {
2716 if ( (fl & DRFL_FAILIFLESS)
2717 && (ulDummy != cb)
2718 )
2719 arc = ERROR_NO_DATA;
2720 else
2721 *pcb = ulDummy; // bytes read
2722 }
2723 }
2724 }
2725 }
2726
2727 return arc;
2728}
2729
2730/*
2731 *@@ doshWrite:
2732 * writes the specified data to the file.
2733 * If (cb == 0), this runs strlen on pcsz
2734 * to find out the length.
2735 *
2736 * If the file is not in binary mode, all
2737 * \n chars are converted to \r\n before
2738 * writing.
2739 *
2740 * Note that this expects that the file
2741 * pointer is at the end of the file, or
2742 * you will get garbage.
2743 *
2744 *@@added V0.9.16 (2001-10-19) [umoeller]
2745 *@@changed V0.9.16 (2001-12-02) [umoeller]: added XOPEN_BINARY \r\n support
2746 *@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
2747 */
2748
2749APIRET doshWrite(PXFILE pFile,
2750 ULONG cb,
2751 PCSZ pbData)
2752{
2753 APIRET arc = NO_ERROR;
2754 if ((!pFile) || (!pbData))
2755 arc = ERROR_INVALID_PARAMETER;
2756 else
2757 {
2758 if (!cb)
2759 cb = strlen(pbData);
2760
2761 if (!cb)
2762 arc = ERROR_INVALID_PARAMETER;
2763 else
2764 {
2765 PSZ pszNew = NULL;
2766
2767 if (!(pFile->flOpenMode & XOPEN_BINARY))
2768 {
2769 // convert all \n to \r\n:
2770 // V0.9.16 (2001-12-02) [umoeller]
2771
2772 // count all \n first
2773 ULONG cNewLines = 0;
2774 PCSZ pSource = pbData;
2775 ULONG ul;
2776 for (ul = 0;
2777 ul < cb;
2778 ul++)
2779 {
2780 if (*pSource++ == '\n')
2781 cNewLines++;
2782 }
2783
2784 if (cNewLines)
2785 {
2786 // we have '\n' chars:
2787 // then we need just as many \r chars inserted
2788 ULONG cbNew = cb + cNewLines;
2789 if (!(pszNew = (PSZ)malloc(cbNew)))
2790 arc = ERROR_NOT_ENOUGH_MEMORY;
2791 else
2792 {
2793 PSZ pTarget = pszNew;
2794 pSource = pbData;
2795 for (ul = 0;
2796 ul < cb;
2797 ul++)
2798 {
2799 CHAR c = *pSource++;
2800 if (c == '\n')
2801 *pTarget++ = '\r';
2802 *pTarget++ = c;
2803 }
2804
2805 cb = cbNew;
2806 }
2807 }
2808 }
2809
2810 if (!arc)
2811 {
2812 ULONG cbWritten;
2813 if (!(arc = DosWrite(pFile->hf,
2814 (pszNew)
2815 ? pszNew
2816 : (PSZ)pbData,
2817 cb,
2818 &cbWritten)))
2819 {
2820 pFile->cbCurrent += cbWritten;
2821 // invalidate the cache
2822 FREE(pFile->pbCache);
2823 }
2824 }
2825
2826 if (pszNew)
2827 free(pszNew);
2828 }
2829 }
2830
2831 return arc;
2832}
2833
2834/*
2835 *@@ doshWriteAt:
2836 * writes cb bytes (pointed to by pbData) to the
2837 * specified file at the position lOffset (from
2838 * the beginning of the file).
2839 *
2840 *@@added V0.9.13 (2001-06-14) [umoeller]
2841 */
2842
2843APIRET doshWriteAt(PXFILE pFile,
2844 ULONG ulOffset, // in: offset to write at
2845 ULONG cb, // in: bytes to write
2846 PCSZ pbData) // in: ptr to bytes to write (must be cb bytes)
2847{
2848 APIRET arc = NO_ERROR;
2849 ULONG cbWritten;
2850 if (!(arc = DosSetFilePtr(pFile->hf,
2851 (LONG)ulOffset,
2852 FILE_BEGIN,
2853 &cbWritten)))
2854 {
2855 if (!(arc = DosWrite(pFile->hf,
2856 (PSZ)pbData,
2857 cb,
2858 &cbWritten)))
2859 {
2860 if (ulOffset + cbWritten > pFile->cbCurrent)
2861 pFile->cbCurrent = ulOffset + cbWritten;
2862 // invalidate the cache V0.9.19 (2002-04-02) [umoeller]
2863 FREE(pFile->pbCache);
2864 }
2865 }
2866
2867 return arc;
2868}
2869
2870/*
2871 *@@ doshWriteLogEntry
2872 * writes a log string to an XFILE, adding a
2873 * leading timestamp before the line.
2874 *
2875 * The internal string buffer is limited to 2000
2876 * characters. Length checking is _not_ performed.
2877 *
2878 *@@added V0.9.16 (2001-10-19) [umoeller]
2879 *@@changed V0.9.16 (2001-12-06) [umoeller]: added check for pFile != NULL
2880 */
2881
2882APIRET doshWriteLogEntry(PXFILE pFile,
2883 const char* pcszFormat,
2884 ...)
2885{
2886 APIRET arc = NO_ERROR;
2887
2888 if ((!pFile) || (!pcszFormat))
2889 arc = ERROR_INVALID_PARAMETER;
2890 else
2891 {
2892 DATETIME dt;
2893 CHAR szTemp[2000];
2894 ULONG ulLength;
2895
2896 DosGetDateTime(&dt);
2897 if (ulLength = sprintf(szTemp,
2898 "%04d-%02d-%02d %02d:%02d:%02d:%02d ",
2899 dt.year, dt.month, dt.day,
2900 dt.hours, dt.minutes, dt.seconds, dt.hundredths))
2901 {
2902 if (!(arc = doshWrite(pFile,
2903 ulLength,
2904 szTemp)))
2905 {
2906 va_list arg_ptr;
2907 va_start(arg_ptr, pcszFormat);
2908 ulLength = vsprintf(szTemp, pcszFormat, arg_ptr);
2909 va_end(arg_ptr);
2910
2911 if (pFile->flOpenMode & XOPEN_BINARY)
2912 // if we're in binary mode, we need to add \r too
2913 szTemp[ulLength++] = '\r';
2914 szTemp[ulLength++] = '\n';
2915
2916 arc = doshWrite(pFile,
2917 ulLength,
2918 szTemp);
2919 }
2920 }
2921 }
2922
2923 return arc;
2924}
2925
2926/*
2927 * doshClose:
2928 * closes an XFILE opened by doshOpen and
2929 * sets *ppFile to NULL.
2930 *
2931 *@@added V0.9.16 (2001-10-19) [umoeller]
2932 */
2933
2934APIRET doshClose(PXFILE *ppFile)
2935{
2936 APIRET arc = NO_ERROR;
2937 PXFILE pFile;
2938
2939 if ( (ppFile)
2940 && (pFile = *ppFile)
2941 )
2942 {
2943 // set the ptr to NULL
2944 *ppFile = NULL;
2945
2946 FREE(pFile->pbCache);
2947 FREE(pFile->pszFilename);
2948
2949 if (pFile->hf)
2950 {
2951 DosSetFileSize(pFile->hf, pFile->cbCurrent);
2952 DosClose(pFile->hf);
2953 pFile->hf = NULLHANDLE;
2954 }
2955
2956 free(pFile);
2957 }
2958 else
2959 arc = ERROR_INVALID_PARAMETER;
2960
2961 return arc;
2962}
2963
2964/*
2965 *@@ doshReadText:
2966 * reads all the contents of the given XFILE into
2967 * a newly allocated buffer. Handles Ctrl-Z properly.
2968 *
2969 * Implementation for doshLoadTextFile, but can
2970 * be called separately now.
2971 *
2972 *@@added V0.9.20 (2002-07-19) [umoeller]
2973 */
2974
2975APIRET doshReadText(PXFILE pFile,
2976 PSZ* ppszContent, // out: newly allocated buffer with file's content
2977 PULONG pcbRead) // out: size of that buffer including null byte (ptr can be NULL)
2978{
2979 APIRET arc;
2980 PSZ pszContent;
2981
2982 if (!(pszContent = (PSZ)malloc(pFile->cbCurrent + 1)))
2983 arc = ERROR_NOT_ENOUGH_MEMORY;
2984 else
2985 {
2986 ULONG cbRead = 0;
2987 if (!(arc = DosRead(pFile->hf,
2988 pszContent,
2989 pFile->cbCurrent,
2990 &cbRead)))
2991 {
2992 if (cbRead != pFile->cbCurrent)
2993 arc = ERROR_NO_DATA;
2994 else
2995 {
2996 PSZ p;
2997 pszContent[cbRead] = '\0';
2998
2999 // check if we have a ctrl-z (EOF) marker
3000 // this is present, for example, in config.sys
3001 // after install, and stupid E.EXE writes this
3002 // all the time when saving a file
3003 // V0.9.18 (2002-03-08) [umoeller]
3004 // if (p = strchr(pszContent, '\26')) What the hell is this??? Octal 26 = Decimal 22 != Ctrl-Z
3005 if (p = strchr(pszContent, '\x1A')) // V1.0.4 (2004-12-18) [pr]
3006 {
3007 *p = '\0';
3008 cbRead = p - pszContent;
3009 }
3010
3011 *ppszContent = pszContent;
3012 if (pcbRead)
3013 *pcbRead = cbRead + 1;
3014 }
3015 }
3016
3017 if (arc)
3018 free(pszContent);
3019 }
3020
3021 return arc;
3022}
3023
3024/*
3025 *@@ doshLoadTextFile:
3026 * reads a text file from disk, allocates memory
3027 * via malloc() and sets a pointer to this
3028 * buffer (or NULL upon errors).
3029 *
3030 * This allocates one extra byte to make the
3031 * buffer null-terminated always. The buffer
3032 * is _not_ converted WRT the line format.
3033 *
3034 * If CTRL-Z (ASCII 26) is encountered in the
3035 * content, it is set to the null character
3036 * instead (V0.9.18).
3037 *
3038 * This returns the APIRET of DosOpen and DosRead.
3039 * If any error occurred, no buffer was allocated.
3040 * Otherwise, you should free() the buffer when
3041 * no longer needed.
3042 *
3043 *@@changed V0.9.7 (2001-01-15) [umoeller]: renamed from doshReadTextFile
3044 *@@changed V0.9.16 (2002-01-05) [umoeller]: added pcbRead
3045 *@@changed V0.9.16 (2002-01-05) [umoeller]: rewritten using doshOpen
3046 *@@changed V0.9.18 (2002-03-08) [umoeller]: fixed ctrl-z (EOF) bug
3047 */
3048
3049APIRET doshLoadTextFile(PCSZ pcszFile, // in: file name to read
3050 PSZ* ppszContent, // out: newly allocated buffer with file's content
3051 PULONG pcbRead) // out: size of that buffer including null byte (ptr can be NULL)
3052{
3053 APIRET arc;
3054
3055 ULONG cbFile = 0;
3056 PXFILE pFile = NULL;
3057
3058 if (!(arc = doshOpen(pcszFile,
3059 XOPEN_READ_EXISTING,
3060 &cbFile,
3061 &pFile)))
3062 {
3063 doshReadText(pFile,
3064 ppszContent,
3065 pcbRead);
3066 doshClose(&pFile);
3067 }
3068
3069 return arc;
3070}
3071
3072/*
3073 *@@ doshCreateBackupFileName:
3074 * creates a valid backup filename of pszExisting
3075 * with a numerical file name extension which does
3076 * not exist in the directory where pszExisting
3077 * resides.
3078 * Returns a PSZ to a new buffer which was allocated
3079 * using malloc().
3080 *
3081 * <B>Example:</B> returns "C:\CONFIG.002" for input
3082 * "C:\CONFIG.SYS" if "C:\CONFIG.001" already exists.
3083 *
3084 *@@changed V0.9.1 (99-12-13) [umoeller]: this crashed if pszExisting had no file extension
3085 */
3086
3087PSZ doshCreateBackupFileName(const char* pszExisting)
3088{
3089 CHAR szFilename[CCHMAXPATH];
3090 PSZ pszLastDot;
3091 ULONG ulCount = 1;
3092 CHAR szCount[5];
3093 ULONG ulDummy;
3094
3095 strcpy(szFilename, pszExisting);
3096
3097 if (!(pszLastDot = strrchr(szFilename, '.')))
3098 // no dot in filename:
3099 pszLastDot = szFilename + strlen(szFilename);
3100
3101 do
3102 {
3103 sprintf(szCount, ".%03lu", ulCount);
3104 strcpy(pszLastDot, szCount);
3105 ulCount++;
3106 } while (!doshQueryPathSize(szFilename, &ulDummy));
3107
3108 return (strdup(szFilename));
3109}
3110
3111/*
3112 *@@ doshCreateTempFileName:
3113 * produces a file name in the the specified directory
3114 * or $(TEMP) which presently doesn't exist. This
3115 * checks the directory for existing files, but does
3116 * not open the temp file.
3117 *
3118 * If (pcszDir != NULL), we look into that directory.
3119 * Otherwise we look into the directory specified
3120 * by the $(TEMP) environment variable.
3121 * If $(TEMP) is not set, $(TMP) is tried next.
3122 *
3123 * If the directory thus specified does not exist, the
3124 * root directory of the boot drive is used instead.
3125 * As a result, this function should be fairly bomb-proof.
3126 *
3127 * If (pcszExt != NULL), the temp file receives
3128 * that extension, or no extension otherwise.
3129 * Do not specify the dot in pcszExt.
3130 *
3131 * pszTempFileName receives the fully qualified
3132 * file name of the temp file in that directory
3133 * and must point to a buffer CCHMAXPATH in size.
3134 * The file name is 8+3 compliant if pcszExt does
3135 * not exceed three characters.
3136 *
3137 * If (pcszPrefix != NULL), the temp file name
3138 * is prefixed with pcszPrefix. Since the temp
3139 * file name must not exceed 8+3 letters, we
3140 * can only use ( 8 - strlen(pcszPrefix ) digits
3141 * for a random number to make the temp file name
3142 * unique. You must therefore use a maximum of
3143 * four characters for the prefix. Otherwise
3144 * ERROR_INVALID_PARAMETER is returned.
3145 *
3146 * Example: Assuming TEMP is set to C:\TEMP,
3147 +
3148 + doshCreateTempFileName(szBuffer,
3149 + NULL, // use $(TEMP)
3150 + "pre", // prefix
3151 + "tmp") // extension
3152 +
3153 * would produce something like "C:\TEMP\pre07FG2.tmp".
3154 *
3155 *@@added V0.9.9 (2001-04-04) [umoeller]
3156 */
3157
3158APIRET doshCreateTempFileName(PSZ pszTempFileName, // out: fully q'fied temp file name
3159 PCSZ pcszDir, // in: dir or NULL for %TEMP%
3160 PCSZ pcszPrefix, // in: prefix for temp file or NULL
3161 PCSZ pcszExt) // in: extension (without dot) or NULL
3162{
3163 APIRET arc = NO_ERROR;
3164
3165 ULONG ulPrefixLen = (pcszPrefix)
3166 ? strlen(pcszPrefix)
3167 : 0;
3168
3169 if ( (!pszTempFileName)
3170 || (ulPrefixLen > 4)
3171 )
3172 arc = ERROR_INVALID_PARAMETER;
3173 else
3174 {
3175 CHAR szDir[CCHMAXPATH] = "";
3176 FILESTATUS3 fs3;
3177
3178 const char *pcszTemp = pcszDir;
3179
3180 if (!pcszTemp)
3181 {
3182 if (!(pcszTemp = getenv("TEMP")))
3183 pcszTemp = getenv("TMP");
3184 }
3185
3186 if (pcszTemp) // either pcszDir or $(TEMP) or $(TMP) now
3187 if (DosQueryPathInfo((PSZ)pcszTemp,
3188 FIL_STANDARD,
3189 &fs3,
3190 sizeof(fs3)))
3191 // TEMP doesn't exist:
3192 pcszTemp = NULL;
3193
3194 if (!pcszTemp)
3195 // not set, or doesn't exist:
3196 // use root directory on boot drive
3197 sprintf(szDir,
3198 "%c:\\",
3199 doshQueryBootDrive());
3200 else
3201 {
3202 strcpy(szDir, pcszTemp);
3203 if (szDir[strlen(szDir) - 1] != '\\')
3204 strcat(szDir, "\\");
3205 }
3206
3207 if (!szDir[0])
3208 arc = ERROR_PATH_NOT_FOUND; // shouldn't happen
3209 else
3210 {
3211 ULONG ulRandom = 0;
3212 ULONG cAttempts = 0;
3213
3214 // produce random number
3215 DosQuerySysInfo(QSV_MS_COUNT,
3216 QSV_MS_COUNT,
3217 &ulRandom,
3218 sizeof(ulRandom));
3219
3220 do
3221 {
3222 CHAR szFile[20] = "",
3223 szFullTryThis[CCHMAXPATH];
3224
3225 // use the lower eight hex digits of the
3226 // system uptime as the temp dir name
3227 sprintf(szFile,
3228 "%08lX",
3229 ulRandom & 0xFFFFFFFF);
3230
3231 // if prefix is specified, overwrite the
3232 // first characters in the random number
3233 if (pcszPrefix)
3234 memcpy(szFile, pcszPrefix, ulPrefixLen);
3235
3236 if (pcszExt)
3237 {
3238 szFile[8] = '.';
3239 strcpy(szFile + 9, pcszExt);
3240 }
3241
3242 // now compose full temp file name
3243 strcpy(szFullTryThis, szDir);
3244 strcat(szFullTryThis, szFile);
3245 // now we have: "C:\temp\wpiXXXXX"
3246 if (DosQueryPathInfo(szFullTryThis,
3247 FIL_STANDARD,
3248 &fs3,
3249 sizeof(fs3))
3250 == ERROR_FILE_NOT_FOUND)
3251 {
3252 // file or dir doesn't exist:
3253 // cool, we're done
3254 strcpy(pszTempFileName, szFullTryThis);
3255 return NO_ERROR;
3256 }
3257
3258 // if this didn't work, raise ulRandom and try again
3259 ulRandom += 123;
3260
3261 // try only 100 times, just to be sure
3262 cAttempts++;
3263 } while (cAttempts < 100);
3264
3265 // 100 loops elapsed:
3266 arc = ERROR_BAD_FORMAT;
3267 }
3268 }
3269
3270 return arc;
3271}
3272
3273/*
3274 *@@ doshWriteTextFile:
3275 * writes a text file to disk; pszFile must contain the
3276 * whole path and filename.
3277 *
3278 * An existing file will be backed up if (pszBackup != NULL),
3279 * using doshCreateBackupFileName. In that case, pszBackup
3280 * receives the name of the backup created, so that buffer
3281 * should be CCHMAXPATH in size.
3282 *
3283 * If (pszbackup == NULL), an existing file will be overwritten.
3284 *
3285 * On success (NO_ERROR returned), *pulWritten receives
3286 * the no. of bytes written.
3287 *
3288 *@@changed V0.9.3 (2000-05-01) [umoeller]: optimized DosOpen; added error checking; changed prototype
3289 *@@changed V0.9.3 (2000-05-12) [umoeller]: added pszBackup
3290 */
3291
3292APIRET doshWriteTextFile(const char* pszFile, // in: file name
3293 const char* pszContent, // in: text to write
3294 PULONG pulWritten, // out: bytes written (ptr can be NULL)
3295 PSZ pszBackup) // in/out: create-backup?
3296{
3297 APIRET arc = NO_ERROR;
3298 ULONG ulWritten = 0;
3299
3300 if ((!pszFile) || (!pszContent))
3301 arc = ERROR_INVALID_PARAMETER;
3302 else
3303 {
3304 ULONG ulAction = 0,
3305 ulLocal = 0;
3306 HFILE hFile = 0;
3307
3308 ULONG ulSize = strlen(pszContent); // exclude 0 byte
3309
3310 if (pszBackup)
3311 {
3312 PSZ pszBackup2 = doshCreateBackupFileName(pszFile);
3313 DosCopy((PSZ)pszFile,
3314 pszBackup2,
3315 DCPY_EXISTING); // delete existing
3316 strcpy(pszBackup, pszBackup2);
3317 free(pszBackup2);
3318 }
3319
3320 if (!(arc = DosOpen((PSZ)pszFile,
3321 &hFile,
3322 &ulAction, // action taken
3323 ulSize, // primary allocation size
3324 FILE_ARCHIVED | FILE_NORMAL, // file attribute
3325 OPEN_ACTION_CREATE_IF_NEW
3326 | OPEN_ACTION_REPLACE_IF_EXISTS, // open flags
3327 OPEN_FLAGS_NOINHERIT
3328 | OPEN_FLAGS_SEQUENTIAL // sequential, not random access
3329 | OPEN_SHARE_DENYWRITE // deny write mode
3330 | OPEN_ACCESS_WRITEONLY, // write mode
3331 NULL))) // no EAs
3332 {
3333 if (!(arc = DosSetFilePtr(hFile,
3334 0L,
3335 FILE_BEGIN,
3336 &ulLocal)))
3337 if (!(arc = DosWrite(hFile,
3338 (PVOID)pszContent,
3339 ulSize,
3340 &ulWritten)))
3341 arc = DosSetFileSize(hFile, ulSize);
3342
3343 DosClose(hFile);
3344 }
3345 } // end if ((pszFile) && (pszContent))
3346
3347 if (pulWritten)
3348 *pulWritten = ulWritten;
3349
3350 return arc;
3351}
3352
3353/*
3354 *@@category: Helpers\Control program helpers\Directory management
3355 * directory helpers (querying, creating, deleting etc.).
3356 */
3357
3358/* ******************************************************************
3359 *
3360 * Directory helpers
3361 *
3362 ********************************************************************/
3363
3364/*
3365 *@@ doshQueryDirExist:
3366 * returns TRUE if the given directory
3367 * exists and really is a directory.
3368 */
3369
3370BOOL doshQueryDirExist(PCSZ pcszDir)
3371{
3372 FILESTATUS3 fs3;
3373 APIRET arc;
3374
3375 if (!(arc = DosQueryPathInfo((PSZ)pcszDir,
3376 FIL_STANDARD,
3377 &fs3,
3378 sizeof(fs3))))
3379 // file found:
3380 return ((fs3.attrFile & FILE_DIRECTORY) != 0);
3381 else
3382 return FALSE;
3383}
3384
3385/*
3386 *@@ doshCreatePath:
3387 * this creates the specified directory.
3388 * As opposed to DosCreateDir, this
3389 * function can create several directories
3390 * at the same time, if the parent
3391 * directories do not exist yet.
3392 */
3393
3394APIRET doshCreatePath(PCSZ pcszPath,
3395 BOOL fHidden) // in: if TRUE, the new directories will get FILE_HIDDEN
3396{
3397 APIRET arc0 = NO_ERROR;
3398 CHAR path[CCHMAXPATH];
3399 CHAR *cp, c;
3400 ULONG cbPath;
3401
3402 strcpy(path, pcszPath);
3403 cbPath = strlen(path);
3404
3405 if (path[cbPath] != '\\')
3406 {
3407 path[cbPath] = '\\';
3408 path[cbPath + 1] = 0;
3409 }
3410
3411 cp = path;
3412 // advance past the drive letter only if we have one
3413 if (*(cp+1) == ':')
3414 cp += 3;
3415
3416 // go!
3417 while (*cp != 0)
3418 {
3419 if (*cp == '\\')
3420 {
3421 c = *cp;
3422 *cp = 0;
3423 if (!doshQueryDirExist(path))
3424 {
3425 APIRET arc = DosCreateDir(path,
3426 0); // no EAs
3427 if (arc != NO_ERROR)
3428 {
3429 arc0 = arc;
3430 break;
3431 }
3432 else
3433 if (fHidden)
3434 {
3435 // hide the directory we just created
3436 doshSetPathAttr(path, FILE_HIDDEN);
3437 }
3438 }
3439 *cp = c;
3440 }
3441 cp++;
3442 }
3443
3444 return (arc0);
3445}
3446
3447/*
3448 *@@ doshQueryCurrentDir:
3449 * writes the current directory into
3450 * the specified buffer, which should be
3451 * CCHMAXPATH in size.
3452 *
3453 * As opposed to DosQueryCurrentDir, this
3454 * includes the drive letter.
3455 *
3456 *@@added V0.9.4 (2000-07-22) [umoeller]
3457 */
3458
3459APIRET doshQueryCurrentDir(PSZ pszBuf)
3460{
3461 APIRET arc = NO_ERROR;
3462 ULONG ulCurDisk = 0;
3463 ULONG ulMap = 0;
3464 if (!(arc = DosQueryCurrentDisk(&ulCurDisk, &ulMap)))
3465 {
3466 ULONG cbBuf = CCHMAXPATH - 3;
3467 pszBuf[0] = ulCurDisk + 'A' - 1;
3468 pszBuf[1] = ':';
3469 pszBuf[2] = '\\';
3470 pszBuf[3] = '\0';
3471 arc = DosQueryCurrentDir(0, pszBuf + 3, &cbBuf);
3472 }
3473
3474 return arc;
3475}
3476
3477/*
3478 *@@ doshDeleteDir:
3479 * deletes a directory. As opposed to DosDeleteDir,
3480 * this removes empty subdirectories and/or files
3481 * as well.
3482 *
3483 * flFlags can be any combination of the following:
3484 *
3485 * -- DOSHDELDIR_RECURSE: recurse into subdirectories.
3486 *
3487 * -- DOSHDELDIR_DELETEFILES: delete all regular files
3488 * which are found on the way.
3489 *
3490 * THIS IS NOT IMPLEMENTED YET.
3491 *
3492 * If 0 is specified, this effectively behaves just as
3493 * DosDeleteDir.
3494 *
3495 * If you specify DOSHDELDIR_RECURSE only, only empty
3496 * subdirectories are deleted as well.
3497 *
3498 * If you specify DOSHDELDIR_RECURSE | DOSHDELDIR_DELETEFILES,
3499 * this removes an entire directory tree, including all
3500 * subdirectories and files.
3501 *
3502 *@@added V0.9.4 (2000-07-01) [umoeller]
3503 *@@changed WarpIN V1.0.15 (2007-03-27) [pr]: allow NULL pulDirs and pulFiles
3504 *@@changed WarpIN V1.0.16 (2007-07-28) [pr]: bump directory count on recursive delete failures @@fixes 1001
3505 *@@changed WarpIN V1.0.20 (2012-03-29) [pr]: path not found no longer an error
3506 */
3507
3508APIRET doshDeleteDir(PCSZ pcszDir,
3509 ULONG flFlags,
3510 PULONG pulDirs, // out: directories found
3511 PULONG pulFiles) // out: files found
3512{
3513 APIRET arc = NO_ERROR,
3514 arcReturn = NO_ERROR;
3515
3516 HDIR hdirFindHandle = HDIR_CREATE;
3517 FILEFINDBUF3 ffb3 = {0}; // returned from FindFirst/Next
3518 ULONG ulResultBufLen = sizeof(FILEFINDBUF3);
3519 ULONG ulFindCount = 1; // look for 1 file at a time
3520
3521 CHAR szFileMask[2*CCHMAXPATH];
3522 sprintf(szFileMask, "%s\\*", pcszDir);
3523
3524 // find files
3525 arc = DosFindFirst(szFileMask,
3526 &hdirFindHandle, // directory search handle
3527 FILE_ARCHIVED | FILE_DIRECTORY | FILE_SYSTEM
3528 | FILE_HIDDEN | FILE_READONLY,
3529 // search attributes; include all, even dirs
3530 &ffb3, // result buffer
3531 ulResultBufLen, // result buffer length
3532 &ulFindCount, // number of entries to find
3533 FIL_STANDARD); // return level 1 file info
3534
3535 if (arc == NO_ERROR)
3536 {
3537 // keep finding the next file until there are no more files
3538 while (arc == NO_ERROR) // != ERROR_NO_MORE_FILES
3539 {
3540 if (ffb3.attrFile & FILE_DIRECTORY)
3541 {
3542 // we found a directory:
3543
3544 // ignore the pseudo-directories
3545 if ( (strcmp(ffb3.achName, ".") != 0)
3546 && (strcmp(ffb3.achName, "..") != 0)
3547 )
3548 {
3549 // real directory:
3550 if (flFlags & DOSHDELDIR_RECURSE)
3551 {
3552 // recurse!
3553 CHAR szSubDir[2*CCHMAXPATH];
3554 sprintf(szSubDir, "%s\\%s", pcszDir, ffb3.achName);
3555 arcReturn = doshDeleteDir(szSubDir,
3556 flFlags,
3557 pulDirs,
3558 pulFiles);
3559 // this removes ffb3.achName as well
3560 }
3561 else
3562 {
3563 // directory, but no recursion:
3564 // report "access denied"
3565 // (this is what OS/2 reports with DosDeleteDir as well)
3566 arcReturn = ERROR_ACCESS_DENIED; // 5
3567 }
3568
3569 if (arcReturn != NO_ERROR) // WarpIN V1.0.16 (2007-07-28) [pr]
3570 if (pulDirs) // WarpIN V1.0.15 (2007-03-27) [pr]
3571 (*pulDirs)++;
3572 }
3573 }
3574 else
3575 {
3576 // it's a file:
3577 arcReturn = ERROR_ACCESS_DENIED;
3578 if (pulFiles) // WarpIN V1.0.15 (2007-03-27) [pr]
3579 (*pulFiles)++;
3580 }
3581
3582 if (arc == NO_ERROR)
3583 {
3584 ulFindCount = 1; // reset find count
3585 arc = DosFindNext(hdirFindHandle, // directory handle
3586 &ffb3, // result buffer
3587 ulResultBufLen, // result buffer length
3588 &ulFindCount); // number of entries to find
3589 }
3590 } // endwhile
3591
3592 DosFindClose(hdirFindHandle); // close our find handle
3593 }
3594
3595 if (arcReturn == NO_ERROR)
3596 {
3597 // success so far:
3598 // delete our directory now
3599 arcReturn = DosDeleteDir((PSZ)pcszDir);
3600 if (arcReturn == ERROR_PATH_NOT_FOUND) // WarpIN V1.0.20 (2012-03-29) [pr]
3601 arcReturn = NO_ERROR;
3602 }
3603
3604 return (arcReturn);
3605}
3606
3607/*
3608 *@@ doshCanonicalize:
3609 * simplifies path specifications to remove '.'
3610 * and '..' entries and generates a fully
3611 * qualified path name where possible.
3612 * File specifications are left unchanged.
3613 *
3614 * This returns:
3615 *
3616 * -- NO_ERROR: the buffers were valid.
3617 *
3618 * -- ERROR_INVALID_PARAMETER: the buffers
3619 * were invalid.
3620 *
3621 *@@added V0.9.19 (2002-04-22) [pr]
3622 */
3623
3624APIRET doshCanonicalize(PCSZ pcszFileIn, // in: path to canonicalize
3625 PSZ pszFileOut, // out: canonicalized path if NO_ERROR
3626 ULONG cbFileOut) // in: size of pszFileOut buffer
3627{
3628 APIRET ulrc = NO_ERROR;
3629 CHAR szFileTemp[CCHMAXPATH];
3630
3631 if (pcszFileIn && pszFileOut && cbFileOut)
3632 {
3633 strncpy(szFileTemp, pcszFileIn, sizeof(szFileTemp) - 1);
3634 szFileTemp[sizeof(szFileTemp) - 1] = 0;
3635 if ( strchr(szFileTemp, '\\')
3636 || strchr(szFileTemp, ':')
3637 )
3638 {
3639 ULONG cbFileTemp = strlen(szFileTemp);
3640
3641 if ( (cbFileTemp > 3)
3642 && (szFileTemp[cbFileTemp - 1] == '\\')
3643 )
3644 {
3645 szFileTemp[cbFileTemp - 1] = 0;
3646 }
3647
3648 if (DosQueryPathInfo(szFileTemp,
3649 FIL_QUERYFULLNAME,
3650 pszFileOut,
3651 cbFileOut))
3652 {
3653 pszFileOut[0] = 0;
3654 }
3655 }
3656 else
3657 {
3658 strncpy(pszFileOut, pcszFileIn, cbFileOut - 1);
3659 pszFileOut[cbFileOut - 1] = 0;
3660 }
3661 }
3662 else
3663 ulrc = ERROR_INVALID_PARAMETER;
3664
3665 return(ulrc);
3666}
3667
3668/*
3669 *@@category: Helpers\Control program helpers\Module handling
3670 * helpers for importing functions from a module (DLL).
3671 */
3672
3673/* ******************************************************************
3674 *
3675 * Module handling helpers
3676 *
3677 ********************************************************************/
3678
3679/*
3680 *@@ doshQueryProcAddr:
3681 * attempts to resolve the given procedure from
3682 * the given module name. Saves you from querying
3683 * the module handle and all that.
3684 *
3685 * This is intended for resolving undocumented
3686 * APIs from OS/2 system DLls such as PMMERGE
3687 * and DOSCALLS. It is assumed that the specified
3688 * module is already loaded.
3689 *
3690 * Returns:
3691 *
3692 * -- NO_ERROR
3693 *
3694 * -- ERROR_INVALID_NAME
3695 *
3696 * -- ERROR_INVALID_ORDINAL
3697 *
3698 * plus the error codes of DosLoadModule.
3699 *
3700 *@@added V0.9.16 (2002-01-13) [umoeller]
3701 */
3702
3703APIRET doshQueryProcAddr(PCSZ pcszModuleName, // in: module name (e.g. "PMMERGE")
3704 ULONG ulOrdinal, // in: proc ordinal
3705 PFN *ppfn) // out: proc address
3706{
3707 HMODULE hmod;
3708 APIRET arc;
3709 if (!(arc = DosQueryModuleHandle((PSZ)pcszModuleName,
3710 &hmod)))
3711 {
3712 if ((arc = DosQueryProcAddr(hmod,
3713 ulOrdinal,
3714 NULL,
3715 ppfn)))
3716 {
3717 // the CP programming guide and reference says use
3718 // DosLoadModule if DosQueryProcAddr fails with this error
3719 if (arc == ERROR_INVALID_HANDLE)
3720 {
3721 if (!(arc = DosLoadModule(NULL,
3722 0,
3723 (PSZ)pcszModuleName,
3724 &hmod)))
3725 {
3726 arc = DosQueryProcAddr(hmod,
3727 ulOrdinal,
3728 NULL,
3729 ppfn);
3730 }
3731 }
3732 }
3733 }
3734
3735 return arc;
3736}
3737
3738/*
3739 *@@ doshResolveImports:
3740 * this function loads the module called pszModuleName
3741 * and resolves imports dynamically using DosQueryProcAddress.
3742 *
3743 * To specify the functions to be imported, a RESOLVEFUNCTION
3744 * array is used. In each of the array items, specify the
3745 * name of the function and a pointer to a function pointer
3746 * where to store the resolved address.
3747 *
3748 *@@added V0.9.3 (2000-04-29) [umoeller]
3749 */
3750
3751APIRET doshResolveImports(PCSZ pcszModuleName, // in: DLL to load
3752 HMODULE *phmod, // out: module handle
3753 PCRESOLVEFUNCTION paResolves, // in/out: function resolves
3754 ULONG cResolves) // in: array item count (not array size!)
3755{
3756 CHAR szName[CCHMAXPATH];
3757 APIRET arc;
3758
3759 if (!(arc = DosLoadModule(szName,
3760 sizeof(szName),
3761 (PSZ)pcszModuleName,
3762 phmod)))
3763 {
3764 ULONG ul;
3765 for (ul = 0;
3766 ul < cResolves;
3767 ul++)
3768 {
3769 if (arc = DosQueryProcAddr(*phmod,
3770 0, // ordinal, ignored
3771 (PSZ)paResolves[ul].pcszFunctionName,
3772 paResolves[ul].ppFuncAddress))
3773 // error:
3774 break;
3775 }
3776
3777 if (arc)
3778 // V0.9.16 (2001-12-08) [umoeller]
3779 DosFreeModule(*phmod);
3780 }
3781
3782 return arc;
3783}
3784
3785/*
3786 *@@category: Helpers\Control program helpers\Performance (CPU load) helpers
3787 * helpers around DosPerfSysCall.
3788 */
3789
3790/* ******************************************************************
3791 *
3792 * Performance Counters (CPU Load)
3793 *
3794 ********************************************************************/
3795
3796/*
3797 *@@ doshPerfOpen:
3798 * initializes the OS/2 DosPerfSysCall API for
3799 * the calling thread.
3800 *
3801 * Note: This API is not supported on all OS/2
3802 * versions. I believe it came up with some Warp 4
3803 * fixpak. The API is resolved dynamically by
3804 * this function (using DosQueryProcAddr).
3805 *
3806 * This properly initializes the internal counters
3807 * which the OS/2 kernel uses for this API. Apparently,
3808 * with newer kernels (FP13/14), IBM has chosen to no
3809 * longer do this automatically, which is the reason
3810 * why many "pulse" utilities display garbage with these
3811 * fixpaks.
3812 *
3813 * After NO_ERROR is returned, DOSHPERFSYS.cProcessors
3814 * contains the no. of processors found on the system.
3815 * All pointers in DOSHPERFSYS then point to arrays
3816 * which have exactly cProcessors array items.
3817 *
3818 * So after NO_ERROR was returned here, you can keep
3819 * calling doshPerfGet to get a current snapshot of the
3820 * IRQ and user loads for each CPU. Note that interrupts
3821 * are only processed on CPU 0 on SMP systems.
3822 *
3823 * Call doshPerfClose to clean up resources allocated
3824 * by this function.
3825 *
3826 * For more sample code, take a look at the "Pulse" widget
3827 * in the XWorkplace sources (src\xcenter\w_pulse.c).
3828 *
3829 * Example code:
3830 *
3831 + PDOSHPERFSYS pPerf = NULL;
3832 + APIRET arc;
3833 + if (!(arc = arc = doshPerfOpen(&pPerf)))
3834 + {
3835 + // this should really be in a timer,
3836 + // e.g. once per second
3837 + ULONG ulCPU;
3838 + if (!(arc = doshPerfGet(&pPerf)))
3839 + {
3840 + // go thru all CPUs
3841 + for (ulCPU = 0; ulCPU < pPerf->cProcessors; ulCPU++)
3842 + {
3843 + LONG lUserLoadThis = pPerf->palLoads[ulCPU];
3844 + ...
3845 + }
3846 + }
3847 +
3848 + // clean up
3849 + doshPerfClose(&pPerf);
3850 + }
3851 +
3852 *
3853 *@@added V0.9.7 (2000-12-02) [umoeller]
3854 *@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3855 */
3856
3857APIRET doshPerfOpen(PDOSHPERFSYS *ppPerfSys) // out: new DOSHPERFSYS structure
3858{
3859 APIRET arc = NO_ERROR;
3860
3861 // allocate DOSHPERFSYS structure
3862 *ppPerfSys = (PDOSHPERFSYS)malloc(sizeof(DOSHPERFSYS));
3863 if (!*ppPerfSys)
3864 arc = ERROR_NOT_ENOUGH_MEMORY;
3865 else
3866 {
3867 // initialize structure
3868 PDOSHPERFSYS pPerfSys = *ppPerfSys;
3869 memset(pPerfSys, 0, sizeof(*pPerfSys));
3870
3871 // resolve DosPerfSysCall API entry
3872 if (!(arc = DosLoadModule(NULL,
3873 0,
3874 "DOSCALLS",
3875 &pPerfSys->hmod)))
3876 {
3877 if (!(arc = DosQueryProcAddr(pPerfSys->hmod,
3878 976,
3879 "DosPerfSysCall",
3880 (PFN*)&pPerfSys->pDosPerfSysCall)))
3881 {
3882 // OK, we got the API: initialize!
3883 if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_ENABLE,
3884 0,
3885 0,
3886 0)))
3887 {
3888 pPerfSys->fInitialized = TRUE;
3889 // call CMD_KI_DISABLE later
3890
3891 if (!(arc = pPerfSys->pDosPerfSysCall(CMD_PERF_INFO,
3892 0,
3893 (ULONG)&pPerfSys->cProcessors,
3894 0)))
3895 {
3896 ULONG ul = 0,
3897 cProcs = pPerfSys->cProcessors,
3898 cbDouble = cProcs * sizeof(double),
3899 cbLong = cProcs * sizeof(LONG);
3900
3901 // allocate arrays
3902 if ( (!(pPerfSys->paCPUUtils = (PCPUUTIL)calloc(cProcs,
3903 sizeof(CPUUTIL))))
3904 || (!(pPerfSys->padBusyPrev
3905 = (double*)malloc(cbDouble)))
3906 || (!(pPerfSys->padTimePrev
3907 = (double*)malloc(cbDouble)))
3908 || (!(pPerfSys->padIntrPrev
3909 = (double*)malloc(cbDouble)))
3910 || (!(pPerfSys->palLoads
3911 = (PLONG)malloc(cbLong)))
3912 || (!(pPerfSys->palIntrs
3913 = (PLONG)malloc(cbLong)))
3914 )
3915 arc = ERROR_NOT_ENOUGH_MEMORY;
3916 else
3917 {
3918 for (ul = 0; ul < cProcs; ul++)
3919 {
3920 pPerfSys->padBusyPrev[ul] = 0.0;
3921 pPerfSys->padTimePrev[ul] = 0.0;
3922 pPerfSys->padIntrPrev[ul] = 0.0;
3923 pPerfSys->palLoads[ul] = 0;
3924 pPerfSys->palIntrs[ul] = 0;
3925 }
3926 }
3927 }
3928 }
3929 } // end if (arc == NO_ERROR)
3930 } // end if (arc == NO_ERROR)
3931
3932 if (arc)
3933 // error: clean up
3934 doshPerfClose(ppPerfSys);
3935
3936 } // end else if (!*ppPerfSys)
3937
3938 return arc;
3939}
3940
3941/*
3942 *@@ doshPerfGet:
3943 * calculates a current snapshot of the system load,
3944 * compared with the load which was calculated on
3945 * the previous call.
3946 *
3947 * If you want to continually measure the system CPU
3948 * load, this is the function you will want to call
3949 * regularly -- e.g. with a timer once per second.
3950 *
3951 * Call this ONLY if doshPerfOpen returned NO_ERROR,
3952 * or you'll get crashes.
3953 *
3954 * If this call returns NO_ERROR, you get LONG load
3955 * values for each CPU in the system in the arrays
3956 * in DOSHPERFSYS (in per-mille, 0-1000).
3957 *
3958 * There are two arrays:
3959 *
3960 * -- DOSHPERFSYS.palLoads contains the "user" load
3961 * for each CPU.
3962 *
3963 * -- DOSHPERFSYS.palIntrs contains the "IRQ" load
3964 * for each CPU.
3965 *
3966 * Sum up the two values to get the total load for
3967 * each CPU.
3968 *
3969 * For example, if there are two CPUs, after this call,
3970 *
3971 * -- DOSHPERFSYS.palLoads[0] contains the "user" load
3972 * of the first CPU,
3973 *
3974 * -- DOSHPERFSYS.palLoads[0] contains the "user" load
3975 * of the second CPU.
3976 *
3977 * See doshPerfOpen for example code.
3978 *
3979 *@@added V0.9.7 (2000-12-02) [umoeller]
3980 *@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
3981 */
3982
3983APIRET doshPerfGet(PDOSHPERFSYS pPerfSys)
3984{
3985 APIRET arc = NO_ERROR;
3986 if (!pPerfSys->pDosPerfSysCall)
3987 arc = ERROR_INVALID_PARAMETER;
3988 else
3989 {
3990 if (!(arc = pPerfSys->pDosPerfSysCall(CMD_KI_RDCNT,
3991 (ULONG)pPerfSys->paCPUUtils,
3992 0, 0)))
3993 {
3994 // go thru all processors
3995 ULONG ul = 0;
3996 for (; ul < pPerfSys->cProcessors; ul++)
3997 {
3998 PCPUUTIL pCPUUtilThis = &pPerfSys->paCPUUtils[ul];
3999
4000 double dTime = LL2F(pCPUUtilThis->ulTimeHigh,
4001 pCPUUtilThis->ulTimeLow);
4002 double dBusy = LL2F(pCPUUtilThis->ulBusyHigh,
4003 pCPUUtilThis->ulBusyLow);
4004 double dIntr = LL2F(pCPUUtilThis->ulIntrHigh,
4005 pCPUUtilThis->ulIntrLow);
4006
4007 double *pdBusyPrevThis = &pPerfSys->padBusyPrev[ul];
4008 double *pdTimePrevThis = &pPerfSys->padTimePrev[ul];
4009 double *pdIntrPrevThis = &pPerfSys->padIntrPrev[ul];
4010
4011 // avoid division by zero
4012 double dTimeDelta;
4013 if (dTimeDelta = (dTime - *pdTimePrevThis))
4014 {
4015 pPerfSys->palLoads[ul]
4016 = (LONG)( (double)( (dBusy - *pdBusyPrevThis)
4017 / dTimeDelta
4018 * 1000.0
4019 )
4020 );
4021 pPerfSys->palIntrs[ul]
4022 = (LONG)( (double)( (dIntr - *pdIntrPrevThis)
4023 / dTimeDelta
4024 * 1000.0
4025 )
4026 );
4027 }
4028 else
4029 {
4030 // no clear readings are available
4031 pPerfSys->palLoads[ul] = 0;
4032 pPerfSys->palIntrs[ul] = 0;
4033 }
4034
4035 *pdTimePrevThis = dTime;
4036 *pdBusyPrevThis = dBusy;
4037 *pdIntrPrevThis = dIntr;
4038 }
4039 }
4040 }
4041
4042 return arc;
4043}
4044
4045/*
4046 *@@ doshPerfClose:
4047 * frees all resources allocated by doshPerfOpen.
4048 *
4049 *@@added V0.9.7 (2000-12-02) [umoeller]
4050 *@@changed V0.9.9 (2001-02-06) [umoeller]: removed disable; this broke the WarpCenter
4051 *@@changed V0.9.9 (2001-03-14) [umoeller]: fixed memory leak
4052 *@@changed V0.9.9 (2001-03-14) [umoeller]: added interrupt loads; thanks phaller
4053 */
4054
4055APIRET doshPerfClose(PDOSHPERFSYS *ppPerfSys)
4056{
4057 APIRET arc = NO_ERROR;
4058 PDOSHPERFSYS pPerfSys;
4059 if ( (!ppPerfSys)
4060 || (!(pPerfSys = *ppPerfSys))
4061 )
4062 arc = ERROR_INVALID_PARAMETER;
4063 else
4064 {
4065 // do not call this, this messes up the WarpCenter V0.9.9 (2001-02-06) [umoeller]
4066 // if (pPerfSys->fInitialized) pPerfSys->pDosPerfSysCall(CMD_KI_DISABLE, 0, 0, 0);
4067
4068 if (pPerfSys->paCPUUtils)
4069 free(pPerfSys->paCPUUtils);
4070 if (pPerfSys->padBusyPrev)
4071 free(pPerfSys->padBusyPrev);
4072 if (pPerfSys->padTimePrev)
4073 free(pPerfSys->padTimePrev);
4074 if (pPerfSys->padIntrPrev)
4075 free(pPerfSys->padIntrPrev);
4076 if (pPerfSys->palLoads) // was missing V0.9.9 (2001-03-14) [umoeller]
4077 free(pPerfSys->palLoads);
4078 if (pPerfSys->palIntrs)
4079 free(pPerfSys->palIntrs);
4080
4081 if (pPerfSys->hmod)
4082 DosFreeModule(pPerfSys->hmod);
4083 free(pPerfSys);
4084 *ppPerfSys = NULL;
4085 }
4086
4087 return arc;
4088}
4089
4090/*
4091 *@@category: Helpers\Control program helpers\Process management
4092 * helpers for starting subprocesses.
4093 */
4094
4095/* ******************************************************************
4096 *
4097 * Process helpers
4098 *
4099 ********************************************************************/
4100
4101STATIC PVOID G_pvLocalInfoSeg = NULL;
4102
4103USHORT _Far16 _Pascal Dos16GetInfoSeg(PSEL pselGlobal,
4104 PSEL pselLocal);
4105
4106/*
4107 * GetInfoSegs:
4108 *
4109 */
4110
4111STATIC VOID GetInfoSegs(VOID)
4112{
4113 SEL GlobalInfoSegSelector,
4114 LocalInfoSegSelector;
4115
4116 // get selectors (old 16-bit API; this gets called only once)
4117 Dos16GetInfoSeg(&GlobalInfoSegSelector,
4118 &LocalInfoSegSelector);
4119 // thunk
4120 /* G_pvGlobalInfoSeg = (PVOID)( (GlobalInfoSegSelector << 0x000D)
4121 & 0x01fff0000); */
4122 G_pvLocalInfoSeg = (PVOID)( (LocalInfoSegSelector << 0x000D)
4123 & 0x01fff0000);
4124}
4125
4126/*
4127 *@@ doshMyPID:
4128 * returns the PID of the current process.
4129 *
4130 * This uses an interesting hack which is way
4131 * faster than DosGetInfoBlocks.
4132 *
4133 *@@added V0.9.9 (2001-04-04) [umoeller]
4134 */
4135
4136ULONG doshMyPID(VOID)
4137{
4138 if (!G_pvLocalInfoSeg)
4139 // first call:
4140 GetInfoSegs();
4141
4142 // PID is at offset 0 in the local info seg
4143 return (*(PUSHORT)G_pvLocalInfoSeg);
4144}
4145
4146/*
4147 *@@ doshMyTID:
4148 * returns the TID of the current thread.
4149 *
4150 * This uses an interesting hack which is way
4151 * faster than DosGetInfoBlocks.
4152 *
4153 *@@added V0.9.9 (2001-04-04) [umoeller]
4154 */
4155
4156ULONG doshMyTID(VOID)
4157{
4158 if (!G_pvLocalInfoSeg)
4159 // first call:
4160 GetInfoSegs();
4161
4162 // TID is at offset 6 in the local info seg
4163 return (*(PUSHORT)((PBYTE)G_pvLocalInfoSeg + 6));
4164}
4165
4166/*
4167 *@@ doshExecVIO:
4168 * executes cmd.exe with the /c parameter
4169 * and pcszExecWithArgs. This is equivalent
4170 * to the C library system() function,
4171 * except that an OS/2 error code is returned
4172 * and that this works with the VAC subsystem
4173 * library.
4174 *
4175 * This uses DosExecPgm and handles the sick
4176 * argument passing.
4177 *
4178 * If NO_ERROR is returned, *plExitCode receives
4179 * the exit code of the process. If the process
4180 * was terminated abnormally, *plExitCode receives:
4181 *
4182 * -- -1: hard error halt
4183 * -- -2: 16-bit trap
4184 * -- -3: DosKillProcess
4185 * -- -4: 32-bit exception
4186 *
4187 *@@added V0.9.4 (2000-07-27) [umoeller]
4188 */
4189
4190APIRET doshExecVIO(PCSZ pcszExecWithArgs,
4191 PLONG plExitCode) // out: exit code (ptr can be NULL)
4192{
4193 APIRET arc = NO_ERROR;
4194
4195 if (strlen(pcszExecWithArgs) > 255)
4196 arc = ERROR_INSUFFICIENT_BUFFER;
4197 else
4198 {
4199 CHAR szObj[CCHMAXPATH];
4200 RESULTCODES res = {0};
4201 CHAR szBuffer[300];
4202
4203 // DosExecPgm expects two args in szBuffer:
4204 // -- cmd.exe\0
4205 // -- then the actual argument, terminated by two 0 bytes.
4206 memset(szBuffer, 0, sizeof(szBuffer));
4207 strcpy(szBuffer, "cmd.exe\0");
4208 sprintf(szBuffer + 8, "/c %s",
4209 pcszExecWithArgs);
4210
4211 arc = DosExecPgm(szObj, sizeof(szObj),
4212 EXEC_SYNC,
4213 szBuffer,
4214 0,
4215 &res,
4216 "cmd.exe");
4217 if ((arc == NO_ERROR) && (plExitCode))
4218 {
4219 if (res.codeTerminate == 0)
4220 // normal exit:
4221 *plExitCode = res.codeResult;
4222 else
4223 *plExitCode = -((LONG)res.codeTerminate);
4224 }
4225 }
4226
4227 return arc;
4228}
4229
4230/*
4231 *@@ doshQuickStartSession:
4232 * this is a shortcut to DosStartSession w/out having to
4233 * deal with all the messy parameters.
4234 *
4235 * This one starts pszPath as a child session and passes
4236 * pszParams to it.
4237 *
4238 * In usPgmCtl, OR any or none of the following (V0.9.0):
4239 * -- SSF_CONTROL_NOAUTOCLOSE (0x0008): do not close automatically.
4240 * This bit is used only for VIO Windowable apps and ignored
4241 * for all other applications.
4242 * -- SSF_CONTROL_MINIMIZE (0x0004)
4243 * -- SSF_CONTROL_MAXIMIZE (0x0002)
4244 * -- SSF_CONTROL_INVISIBLE (0x0001)
4245 * -- SSF_CONTROL_VISIBLE (0x0000)
4246 *
4247 * Specifying 0 will therefore auto-close the session and make it
4248 * visible.
4249 *
4250 * If (fWait), this function will create a termination queue
4251 * and not return until the child session has ended. Be warned,
4252 * this blocks the calling thread.
4253 *
4254 * Otherwise the function will return immediately.
4255 *
4256 * The session and process IDs of the child session will be
4257 * written to *pulSID and *ppid. Of course, in "wait" mode,
4258 * these are no longer valid after this function returns.
4259 *
4260 * Returns the error code of DosStartSession.
4261 *
4262 * Note: According to CPREF, calling DosStartSession calls
4263 * DosExecPgm in turn for all full-screen, VIO, and PM sessions.
4264 *
4265 *@@changed V0.9.0 [umoeller]: prototype changed to include usPgmCtl
4266 *@@changed V0.9.1 (99-12-30) [umoeller]: queue was sometimes not closed. Fixed.
4267 *@@changed V0.9.3 (2000-05-03) [umoeller]: added fForeground
4268 *@@changed V0.9.14 (2001-08-03) [umoeller]: fixed potential queue leak
4269 *@@changed V0.9.14 (2001-08-03) [umoeller]: fixed memory leak in wait mode; added pusReturn to prototype
4270 *@@changed V1.0.4 (2005-10-16) [jsmall ]: inserted new 3rd parameter for session type
4271 *@@changed V1.0.4 (2005-10-16) [jsmall ]: changed code so when fWait = FALSE then session is started as independent, not as a child
4272 *@@changed V1.0.5 (2006-04-01) [pr]: Added pcszTitle parameter
4273 */
4274
4275APIRET doshQuickStartSession(PCSZ pcszPath, // in: program to start
4276 PCSZ pcszParams, // in: parameters for program
4277 PCSZ pcszTitle, // in: window title
4278 USHORT usSessionType, // in: session type
4279 BOOL fForeground, // in: if TRUE, session will be in foreground
4280 USHORT usPgmCtl, // in: STARTDATA.PgmControl
4281 BOOL fWait, // in: wait for termination?
4282 PULONG pulSID, // out: session ID (req.)
4283 PPID ppid, // out: process ID (req.)
4284 PUSHORT pusReturn) // out: in wait mode, session's return code (ptr can be NULL)
4285{
4286 APIRET arc = NO_ERROR;
4287 // queue stuff
4288 const char *pcszQueueName = "\\queues\\xwphlpsw.que";
4289 HQUEUE hq = 0;
4290 PID qpid = 0;
4291
4292 if (fWait)
4293 {
4294 if (!(arc = DosCreateQueue(&hq,
4295 QUE_FIFO | QUE_CONVERT_ADDRESS,
4296 (PSZ)pcszQueueName)))
4297 arc = DosOpenQueue(&qpid, &hq, (PSZ)pcszQueueName);
4298 }
4299
4300 if (!arc) // V0.9.14 (2001-08-03) [umoeller]
4301 {
4302 STARTDATA SData;
4303 CHAR szObjBuf[CCHMAXPATH];
4304
4305 SData.Length = sizeof(STARTDATA);
4306 SData.Related = (fWait) ? SSF_RELATED_CHILD : SSF_RELATED_INDEPENDENT;
4307 // V1.0.4 (2005-10-16) [jsmall]
4308 SData.FgBg = (fForeground) ? SSF_FGBG_FORE : SSF_FGBG_BACK;
4309 // V0.9.3 (2000-05-03) [umoeller]
4310 SData.TraceOpt = SSF_TRACEOPT_NONE;
4311
4312 // V1.0.5 (2006-04-01) [pr]
4313 if (pcszTitle && *pcszTitle)
4314 SData.PgmTitle = (PSZ)pcszTitle; // title for window
4315 else
4316 SData.PgmTitle = (PSZ)pcszPath;
4317
4318 SData.PgmName = (PSZ)pcszPath;
4319 SData.PgmInputs = (PSZ)pcszParams;
4320
4321 SData.TermQ = (fWait) ? (PSZ)pcszQueueName : NULL;
4322 SData.Environment = 0;
4323 SData.InheritOpt = SSF_INHERTOPT_PARENT;
4324 SData.SessionType = usSessionType; // V1.0.4 (2005-10-16) [jsmall]
4325 SData.IconFile = 0;
4326 SData.PgmHandle = 0;
4327
4328 SData.PgmControl = usPgmCtl;
4329
4330 SData.InitXPos = 30;
4331 SData.InitYPos = 40;
4332 SData.InitXSize = 200;
4333 SData.InitYSize = 140;
4334 SData.Reserved = 0;
4335 SData.ObjectBuffer = szObjBuf;
4336 SData.ObjectBuffLen = (ULONG)sizeof(szObjBuf);
4337
4338 if ( (!(arc = DosStartSession(&SData, pulSID, ppid)))
4339 && (fWait)
4340 )
4341 {
4342 // block on the termination queue, which is written
4343 // to when the subprocess ends
4344 REQUESTDATA rqdata;
4345 ULONG cbData = 0;
4346 PULONG pulData = NULL;
4347 BYTE elpri;
4348
4349 rqdata.pid = qpid;
4350 if (!(arc = DosReadQueue(hq, // in: queue handle
4351 &rqdata, // out: pid and ulData
4352 &cbData, // out: size of data returned
4353 (PVOID*)&pulData, // out: data returned
4354 0, // in: remove first element in queue
4355 0, // in: wait for queue data (block thread)
4356 &elpri, // out: element's priority
4357 0))) // in: event semaphore to be posted
4358 {
4359 if (!rqdata.ulData)
4360 {
4361 // child session ended:
4362 // V0.9.14 (2001-08-03) [umoeller]
4363
4364 // *pulSID = (*pulData) & 0xffff;
4365 if (pusReturn)
4366 *pusReturn = ((*pulData) >> 16) & 0xffff;
4367
4368 }
4369 // else: continue looping
4370
4371 if (pulData)
4372 DosFreeMem(pulData);
4373 }
4374 }
4375 }
4376
4377 if (hq)
4378 DosCloseQueue(hq);
4379
4380 return arc;
4381}
4382
4383
Note: See TracBrowser for help on using the repository browser.