source: trunk/dll/valid.c@ 765

Last change on this file since 765 was 697, checked in by Steven Levine, 18 years ago

More OpenWatcom compatibility updates
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.4 KB
Line 
1
2/***********************************************************************
3
4 $Id: valid.c 697 2007-06-17 03:59:25Z stevenhl $
5
6 File name manipulation routines
7
8 Copyright (c) 1993, 1998 M. Kimes
9 Copyright (c) 2002, 2007 Steven H.Levine
10
11 23 Nov 02 SHL RootName: rework for sanity
12 27 Nov 02 SHL MakeFullName: correct typo
13 11 Jun 03 SHL Add JFS and FAT32 support
14 15 Jun 04 SHL Implement Jim Read's removable logic
15 31 Jul 04 SHL Comments
16 01 Aug 04 SHL Rework lstrip/rstrip usage
17 03 Jun 05 SHL Drop CD_DEBUG logic
18 28 Nov 05 SHL MakeValidDir: correct DosQuerySysInfo args
19 22 Jul 06 SHL Use Runtime_Error
20 22 Oct 06 GKY Add NDFS32 support
21 22 Oct 06 GKY Increased BUFFER_BYTES in CheckDrive to 8192 to fix NDFS32 scan failure
22 07 Jan 07 GKY Move error strings etc. to string file
23 18 Feb 07 GKY Add more drive types and icons
24 16 Jun 07 SHL Update for OpenWatcom
25
26***********************************************************************/
27
28#define INCL_DOS
29#define INCL_WIN
30#define INCL_DOSDEVICES // DosDevIOCtl
31#define INCL_DOSDEVIOCTL // DosDevIOCtl
32#include <os2.h>
33
34#include <stdlib.h>
35#include <stdio.h>
36#include <string.h>
37#include <ctype.h>
38
39#include "fm3dll.h"
40#include "fm3str.h"
41
42static PSZ pszSrcFile = __FILE__;
43
44#pragma alloc_text(VALID,CheckDrive,IsRoot,IsFile,IsFullName,needsquoting)
45#pragma alloc_text(VALID,IsValidDir,IsValidDrive,MakeValidDir,IsVowel)
46#pragma alloc_text(VALID,IsFileSame,IsNewer,TestDates,RootName,MakeFullName)
47#pragma alloc_text(VALID,IsExecutable,IsBinary,IsDesktop,ParentIsDesktop)
48#pragma alloc_text(FILLFLAGS,FillInDriveFlags,assign_ignores)
49#pragma alloc_text(FILLFLAGS,ArgDriveFlags,DriveFlagsOne)
50#pragma alloc_text(FINDDESK,GetDesktopName)
51
52APIRET MakeFullName(char *pszFileName)
53{
54 /* pszFileName must be CCHMAXPATH long minimum! */
55
56 char szPathName[CCHMAXPATH];
57 APIRET rc;
58
59 DosError(FERR_DISABLEHARDERR);
60 rc = DosQueryPathInfo(pszFileName,
61 FIL_QUERYFULLNAME, szPathName, sizeof(szPathName));
62 if (!rc)
63 strcpy(pszFileName, szPathName); // Pass back actual name
64 return rc;
65}
66
67char *RootName(char *filename)
68{
69 char *p = NULL, *pp;
70
71 // Return filename, strip path parts
72 // Return empty string when filename ends with backslash
73
74 if (filename) {
75 p = strrchr(filename, '\\');
76 pp = strrchr(filename, '/');
77 p = (p) ? (pp) ? (p > pp) ? p : pp : p : pp;
78 }
79 if (!p) /* name is itself a root */
80 p = filename;
81 else /* skip past backslash */
82 p++;
83 return p;
84}
85
86int TestDates(char *file1, char *file2)
87{
88 /*
89 * return 1 (file2 newer than file1),
90 * 0 (files same)
91 * or -1 (file1 newer than file2)
92 */
93
94 int comp = 0;
95 FILESTATUS3 fs3o, fs3n;
96
97 DosError(FERR_DISABLEHARDERR);
98 if (!DosQueryPathInfo(file1, FIL_STANDARD, &fs3o, sizeof(fs3o))) {
99 DosError(FERR_DISABLEHARDERR);
100 if (!DosQueryPathInfo(file2, FIL_STANDARD, &fs3n, sizeof(fs3n))) {
101 comp = (fs3n.fdateLastWrite.year >
102 fs3o.fdateLastWrite.year) ? 1 :
103 (fs3n.fdateLastWrite.year <
104 fs3o.fdateLastWrite.year) ? -1 :
105 (fs3n.fdateLastWrite.month >
106 fs3o.fdateLastWrite.month) ? 1 :
107 (fs3n.fdateLastWrite.month <
108 fs3o.fdateLastWrite.month) ? -1 :
109 (fs3n.fdateLastWrite.day >
110 fs3o.fdateLastWrite.day) ? 1 :
111 (fs3n.fdateLastWrite.day <
112 fs3o.fdateLastWrite.day) ? -1 :
113 (fs3n.ftimeLastWrite.hours >
114 fs3o.ftimeLastWrite.hours) ? 1 :
115 (fs3n.ftimeLastWrite.hours <
116 fs3o.ftimeLastWrite.hours) ? -1 :
117 (fs3n.ftimeLastWrite.minutes >
118 fs3o.ftimeLastWrite.minutes) ? 1 :
119 (fs3n.ftimeLastWrite.minutes <
120 fs3o.ftimeLastWrite.minutes) ? -1 :
121 (fs3n.ftimeLastWrite.twosecs >
122 fs3o.ftimeLastWrite.twosecs) ? 1 :
123 (fs3n.ftimeLastWrite.twosecs < fs3o.ftimeLastWrite.twosecs) ? -1 : 0;
124 }
125 }
126 return comp;
127}
128
129BOOL IsNewer(char *file1, char *file2)
130{
131 /* return TRUE if file2 is newer than file1 */
132
133 return (TestDates(file1, file2) > 0);
134}
135
136BOOL IsDesktop(HAB hab, HWND hwnd)
137{
138 HWND hwndDesktop;
139
140 if (hwnd == HWND_DESKTOP)
141 return TRUE;
142 hwndDesktop = WinQueryDesktopWindow(hab, NULLHANDLE);
143 if (hwnd == hwndDesktop)
144 return TRUE;
145 return FALSE;
146}
147
148BOOL ParentIsDesktop(HWND hwnd, HWND hwndParent)
149{
150 HWND hwndDesktop;
151 BOOL ret = FALSE;
152
153 if (!hwndParent)
154 hwndParent = WinQueryWindow(hwnd, QW_PARENT);
155 if (hwndParent == HWND_DESKTOP)
156 ret = TRUE;
157 else {
158 hwndDesktop = WinQueryDesktopWindow(WinQueryAnchorBlock(hwnd), (HWND) 0);
159 if (hwndDesktop == hwndParent)
160 ret = TRUE;
161 }
162 return ret;
163}
164
165/* CheckDrive
166 * @param chDrive drive letter
167 * @param pszFileSystem pointer to buffer to return file system type or NULL
168 * @param pulType pointer to long word to return drive flags or NULL
169 * @returns removability flag, 1 = removable, 0 = not removable, -1 = error
170 */
171
172INT CheckDrive(CHAR chDrive, CHAR * pszFileSystem, ULONG * pulType)
173{
174 CHAR szPath[3];
175 VOID *pvBuffer = NULL;
176 CHAR *pfsn;
177 CHAR *pfsd;
178 ULONG clBufferSize;
179 APIRET rc;
180 ULONG ulAction;
181 ULONG clParmBytes;
182 ULONG clDataBytes;
183 HFILE hDev;
184
185# pragma pack(1)
186 struct
187 {
188 BYTE Cmd;
189 BYTE Unit;
190 }
191 parmPkt =
192 {
193 0, 0};
194# define BPB_REMOVABLE_MEDIA 0x08 // 3 - Media is removable
195 struct
196 {
197 BIOSPARAMETERBLOCK bpb;
198 USHORT cCylinders; // Documented but not implemented
199 BYTE bDeviceType; // Documented but not implemented
200 USHORT fsDeviceAttr; // Documented but not implemented
201 }
202 dataPkt;
203
204# pragma pack()
205 BYTE NonRemovable;
206 PFSQBUFFER2 pfsq;
207
208 if (pszFileSystem)
209 *pszFileSystem = 0;
210
211 if (pulType)
212 *pulType = 0;
213
214# define BUFFER_BYTES 8192
215 rc = DosAllocMem(&pvBuffer, BUFFER_BYTES,
216 PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
217 if (rc) {
218 Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
219 GetPString(IDS_OUTOFMEMORY));
220 return -1; // Say failed
221 }
222
223 szPath[0] = chDrive;
224 szPath[1] = ':';
225 szPath[2] = 0;
226 clBufferSize = BUFFER_BYTES;
227 DosError(FERR_DISABLEHARDERR);
228 rc = DosQueryFSAttach(szPath, 0, FSAIL_QUERYNAME,
229 (PFSQBUFFER2) pvBuffer, &clBufferSize);
230 if (rc) {
231 /* can't get any info at all */
232 DosFreeMem(pvBuffer);
233 DosError(FERR_DISABLEHARDERR);
234 return -1; // Say failed
235 }
236
237 pfsq = (PFSQBUFFER2) pvBuffer;
238 pfsn = (PCHAR)(pfsq->szName) + pfsq->cbName + 1;
239 pfsd = pfsn + pfsq->cbFSDName + 1;
240
241 if (pszFileSystem) {
242 strncpy(pszFileSystem, pfsn, CCHMAXPATH);
243 pszFileSystem[CCHMAXPATH - 1] = 0;
244 }
245
246 if (pulType && (!strcmp(pfsn, CDFS) || !strcmp(pfsn, ISOFS)))
247 *pulType |= DRIVE_NOTWRITEABLE | DRIVE_CDROM | DRIVE_REMOVABLE;
248 if (pulType && !strcmp(pfsn, NTFS))
249 *pulType |= DRIVE_NOTWRITEABLE;
250 if (pulType && !strcmp(pfsn, NDFS32)){
251 *pulType |= DRIVE_VIRTUAL;
252 }
253 if (pulType && !strcmp(pfsn, RAMFS)){
254 *pulType |= DRIVE_RAMDISK;
255 }
256 if (((PFSQBUFFER2) pvBuffer)->iType == FSAT_REMOTEDRV &&
257 (strcmp(pfsn, CDFS) || strcmp(pfsn, ISOFS))) {
258 if (pulType)
259 *pulType |= DRIVE_REMOTE;
260
261 if (pulType && !strcmp(pfsn, CBSIFS)) {
262 *pulType |= DRIVE_ZIPSTREAM;
263 *pulType &= ~DRIVE_REMOTE;
264 *pulType |= DRIVE_NOLONGNAMES;
265 if (pfsq->cbFSAData) {
266 ULONG FType;
267
268 if (CheckDrive(*pfsd, NULL, &FType) != -1) {
269 if (FType & DRIVE_REMOVABLE)
270 *pulType |= DRIVE_REMOVABLE;
271 if (~FType & DRIVE_NOLONGNAMES)
272 *pulType &= ~DRIVE_NOLONGNAMES;
273 }
274
275 }
276 }
277 if (pulType &&
278 (!strcmp(pfsn, HPFS) ||
279 !strcmp(pfsn, JFS) ||
280 !strcmp(pfsn, FAT32) ||
281 !strcmp(pfsn, RAMFS) ||
282 !strcmp(pfsn, NDFS32) ||
283 !strcmp(pfsn, NTFS) ||
284 !strcmp(pfsn, HPFS386))) {
285 *pulType &= ~DRIVE_NOLONGNAMES;
286 }
287
288 DosFreeMem(pvBuffer);
289 return 0; // Remotes are non-removable
290 }
291
292 // Local drive
293 if (strcmp(pfsn, HPFS) &&
294 strcmp(pfsn, JFS) &&
295 strcmp(pfsn, CDFS) &&
296 strcmp(pfsn, ISOFS) &&
297 strcmp(pfsn, RAMFS) &&
298 strcmp(pfsn, FAT32) &&
299 strcmp(pfsn, NDFS32) &&
300 strcmp(pfsn, NTFS) &&
301 strcmp(pfsn, HPFS386)) {
302 if (pulType)
303 (*pulType) |= DRIVE_NOLONGNAMES; // Others can not have long names
304 }
305
306
307 DosError(FERR_DISABLEHARDERR);
308 rc = DosOpen(szPath, &hDev, &ulAction, 0, 0, FILE_OPEN,
309 OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE |
310 OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR, 0);
311 if (rc) {
312 DosError(FERR_DISABLEHARDERR);
313 if (pulType)
314 *pulType |= DRIVE_REMOVABLE; // Assume removable if can not access
315 DosFreeMem(pvBuffer);
316 return 1; // Say removable
317 }
318
319 clParmBytes = sizeof(parmPkt.Cmd);
320 clDataBytes = sizeof(NonRemovable);
321 NonRemovable = 1; // Preset as non removable
322 DosError(FERR_DISABLEHARDERR);
323 rc = DosDevIOCtl(hDev, IOCTL_DISK, DSK_BLOCKREMOVABLE, &parmPkt.Cmd, /* Address of the command-specific argument list. */
324 sizeof(parmPkt.Cmd), /* Length, in bytes, of pParams. */
325 &clParmBytes, /* Pointer to the length of parameters. */
326 &NonRemovable, /* Address of the data area. */
327 sizeof(NonRemovable), /* Length, in bytes, of pData. */
328 &clDataBytes); /* Pointer to the length of data. */
329
330 if (!rc && NonRemovable) {
331 // Could be USB so check BPB flags
332 clParmBytes = sizeof(parmPkt.Cmd);
333 clDataBytes = sizeof(dataPkt);
334 memset(&dataPkt, 0xff, sizeof(dataPkt));
335 DosError(FERR_DISABLEHARDERR);
336 rc = DosDevIOCtl(hDev, IOCTL_DISK, DSK_GETDEVICEPARAMS, &parmPkt.Cmd, /* Address of the command-specific argument list. */
337 sizeof(parmPkt.Cmd), /* Length, in bytes, of pParams. */
338 &clParmBytes, /* Pointer to the length of parameters. */
339 &dataPkt, /* Address of the data area. */
340 sizeof(dataPkt), /* Length, in bytes, of pData. */
341 &clDataBytes); /* Pointer to the length of data. */
342
343 if (!rc && (dataPkt.bpb.fsDeviceAttr & BPB_REMOVABLE_MEDIA))
344 NonRemovable = 0;
345 }
346
347 DosClose(hDev);
348
349 if (!NonRemovable && pulType)
350 *pulType |= DRIVE_REMOVABLE;
351
352 DosFreeMem(pvBuffer);
353
354 return NonRemovable ? 0 : 1;
355}
356
357BOOL IsFileSame(CHAR * filename1, CHAR * filename2)
358{
359 /* returns: -1 (error), 0 (is a directory), or 1 (is a file) */
360
361 FILESTATUS3 fsa1, fsa2;
362 APIRET ret;
363
364 if (filename1 && filename2) {
365 DosError(FERR_DISABLEHARDERR);
366 ret = DosQueryPathInfo(filename1, FIL_STANDARD, &fsa1,
367 (ULONG) sizeof(fsa1));
368 if (!ret) {
369 DosError(FERR_DISABLEHARDERR);
370 ret = DosQueryPathInfo(filename2, FIL_STANDARD, &fsa2,
371 (ULONG) sizeof(fsa2));
372 if (!ret) {
373 if (fsa1.cbFile == fsa2.cbFile &&
374 (fsa1.attrFile & (~FILE_ARCHIVED)) ==
375 (fsa2.attrFile & (~FILE_ARCHIVED)))
376 return TRUE;
377 }
378 }
379 }
380 return FALSE;
381}
382
383INT IsFile(CHAR * filename)
384{
385 /* returns: -1 (error), 0 (is a directory), or 1 (is a file) */
386
387 FILESTATUS3 fsa;
388 APIRET ret;
389
390 if (filename && *filename) {
391 DosError(FERR_DISABLEHARDERR);
392 ret = DosQueryPathInfo(filename, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa));
393 if (!ret)
394 return ((fsa.attrFile & FILE_DIRECTORY) == 0);
395 else if (IsValidDrive(*filename) && IsRoot(filename))
396 return 0;
397 }
398 return -1; /* error; doesn't exist or can't read or null filename */
399}
400
401BOOL IsFullName(CHAR * filename)
402{
403 return (filename) ?
404 (isalpha(*filename) && filename[1] == ':' && filename[2] == '\\') : 0;
405}
406
407BOOL IsRoot(CHAR * filename)
408{
409 return (filename && isalpha(*filename) && filename[1] == ':' &&
410 filename[2] == '\\' && !filename[3]);
411}
412
413BOOL IsValidDir(CHAR * path)
414{
415 CHAR fullname[CCHMAXPATH];
416 FILESTATUS3 fs;
417
418 if (path) {
419 DosError(FERR_DISABLEHARDERR);
420 if (!DosQueryPathInfo(path,
421 FIL_QUERYFULLNAME, fullname, sizeof(fullname))) {
422 if (IsValidDrive(*fullname)) {
423 if (!IsRoot(fullname)) {
424 DosError(FERR_DISABLEHARDERR);
425 if (!DosQueryPathInfo(fullname,
426 FIL_STANDARD,
427 &fs,
428 sizeof(fs)) && (fs.attrFile & FILE_DIRECTORY))
429 return TRUE;
430 }
431 else
432 return TRUE;
433 }
434 }
435 }
436 return FALSE;
437}
438
439BOOL IsValidDrive(CHAR drive)
440{
441 CHAR Path[] = " :", Buffer[256];
442 APIRET Status;
443 ULONG Size;
444 ULONG ulDriveNum, ulDriveMap;
445
446 if (!isalpha(drive) ||
447 (driveflags[toupper(drive) - 'A'] & (DRIVE_IGNORE | DRIVE_INVALID)))
448 return FALSE;
449 DosError(FERR_DISABLEHARDERR);
450 Status = DosQCurDisk(&ulDriveNum, &ulDriveMap);
451 if (!Status) {
452 if (!(ulDriveMap & (1L << (ULONG) (toupper(drive) - 'A'))))
453 return FALSE;
454 Path[0] = toupper(drive);
455 Size = sizeof(Buffer);
456 DosError(FERR_DISABLEHARDERR);
457 Status = DosQueryFSAttach(Path,
458 0,
459 FSAIL_QUERYNAME, (PFSQBUFFER2) Buffer, &Size);
460 }
461 return (Status == 0);
462}
463
464//=== MakeValidDir() build valid directory name ===
465
466CHAR *MakeValidDir(CHAR * path)
467{
468 ULONG ulDrv;
469 CHAR *p;
470 FILESTATUS3 fs;
471 APIRET rc;
472
473 if (!MakeFullName(path)) {
474 if (IsValidDrive(*path)) {
475 // Passed name is valid - trim to directory
476 for (;;) {
477 if (IsRoot(path))
478 return path;
479 DosError(FERR_DISABLEHARDERR);
480 rc = DosQueryPathInfo(path, FIL_STANDARD, &fs, sizeof(fs));
481 if (!rc && (fs.attrFile & FILE_DIRECTORY))
482 return path;
483 p = strrchr(path, '\\');
484 if (p) {
485 if (p < path + 3)
486 p++;
487 *p = 0;
488 }
489 else
490 break;
491 }
492 }
493 }
494 // Fall back to boot drive
495 DosError(FERR_DISABLEHARDERR);
496 if (!DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &ulDrv, sizeof(ulDrv))) {
497 ulDrv += '@';
498 if (ulDrv < 'C')
499 ulDrv = 'C';
500 strcpy(path, " :\\");
501 *path = (CHAR) ulDrv;
502 }
503 else
504 save_dir2(path); // Fall back to fm3.ini drive or current dir - should never occur
505 return path;
506}
507
508BOOL IsExecutable(CHAR * filename)
509{
510 register CHAR *p;
511 APIRET ret;
512 ULONG apptype;
513
514 if (filename) {
515 DosError(FERR_DISABLEHARDERR);
516 p = strrchr(filename, '.');
517 if (p)
518 ret = DosQueryAppType(filename, &apptype);
519 else {
520
521 char fname[CCHMAXPATH + 2];
522
523 strcpy(fname, filename);
524 strcat(fname, ".");
525 ret = DosQueryAppType(fname, &apptype);
526 }
527 if ((!ret && (!apptype ||
528 (apptype &
529 (FAPPTYP_NOTWINDOWCOMPAT |
530 FAPPTYP_WINDOWCOMPAT |
531 FAPPTYP_WINDOWAPI |
532 FAPPTYP_BOUND |
533 FAPPTYP_DOS |
534 FAPPTYP_WINDOWSREAL |
535 FAPPTYP_WINDOWSPROT |
536 FAPPTYP_32BIT |
537 0x1000)))) ||
538 (p && (!stricmp(p, ".CMD") || !stricmp(p, ".BAT"))))
539 return TRUE;
540 }
541 return FALSE;
542}
543
544VOID ArgDriveFlags(INT argc, CHAR ** argv)
545{
546 INT x;
547
548 for (x = 1; x < argc; x++) {
549 if (*argv[x] == '/' && isalpha(argv[x][1])) {
550
551 CHAR *p = &argv[x][1];
552
553 while (isalpha(*p)) {
554 driveflags[toupper(*p) - 'A'] |= DRIVE_IGNORE;
555 p++;
556 }
557 }
558 else if (*argv[x] == ';' && isalpha(argv[x][1])) {
559
560 CHAR *p = &argv[x][1];
561
562 while (isalpha(*p)) {
563 driveflags[toupper(*p) - 'A'] |= DRIVE_NOPRESCAN;
564 p++;
565 }
566 }
567 else if (*argv[x] == '`' && isalpha(argv[x][1])) {
568
569 CHAR *p = &argv[x][1];
570
571 while (isalpha(*p)) {
572 driveflags[toupper(*p) - 'A'] |= DRIVE_NOSTATS;
573 p++;
574 }
575 }
576 else if (*argv[x] == ',' && isalpha(argv[x][1])) {
577
578 CHAR *p = &argv[x][1];
579
580 while (isalpha(*p)) {
581 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADICONS;
582 p++;
583 }
584 }
585 else if (*argv[x] == '-' && isalpha(argv[x][1])) {
586
587 CHAR *p = &argv[x][1];
588
589 while (isalpha(*p)) {
590 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADSUBJS;
591 p++;
592 }
593 }
594 else if (*argv[x] == '\'' && isalpha(argv[x][1])) {
595
596 CHAR *p = &argv[x][1];
597
598 while (isalpha(*p)) {
599 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADLONGS;
600 p++;
601 }
602 }
603 }
604}
605
606VOID DriveFlagsOne(INT x)
607{
608 INT removable;
609 CHAR szDrive[] = " :\\", FileSystem[CCHMAXPATH];
610 ULONG drvtype;
611
612 *szDrive = (CHAR) (x + 'A');
613 *FileSystem = 0;
614 drvtype = 0;
615 removable = CheckDrive(*szDrive, FileSystem, &drvtype);
616 driveserial[x] = -1;
617 driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
618 DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
619 DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS);
620 if (removable != -1) {
621 struct
622 {
623 ULONG serial;
624 CHAR volumelength;
625 CHAR volumelabel[CCHMAXPATH];
626 }
627 volser;
628
629 DosError(FERR_DISABLEHARDERR);
630 if (!DosQueryFSInfo((ULONG) x + 1, FSIL_VOLSER, &volser, sizeof(volser)))
631 driveserial[x] = volser.serial;
632 else
633 DosError(FERR_DISABLEHARDERR);
634 }
635 else
636 driveflags[x] |= DRIVE_INVALID;
637 driveflags[x] |= ((removable == -1 || removable == 1) ?
638 DRIVE_REMOVABLE : 0);
639 if (drvtype & DRIVE_REMOTE)
640 driveflags[x] |= DRIVE_REMOTE;
641 if(!stricmp(FileSystem,NDFS32)){
642 driveflags[x] |= DRIVE_VIRTUAL;
643 driveflags[x] &= (~DRIVE_REMOTE);
644 }
645 if(!stricmp(FileSystem,RAMFS)){
646 driveflags[x] |= DRIVE_RAMDISK;
647 driveflags[x] &= (~DRIVE_REMOTE);
648 }
649 if(!stricmp(FileSystem,NTFS))
650 driveflags[x] |= DRIVE_NOTWRITEABLE;
651 if (strcmp(FileSystem, HPFS) &&
652 strcmp(FileSystem, JFS) &&
653 strcmp(FileSystem, CDFS) &&
654 strcmp(FileSystem, ISOFS) &&
655 strcmp(FileSystem, RAMFS) &&
656 strcmp(FileSystem, FAT32) &&
657 strcmp(FileSystem, NTFS) &&
658 strcmp(FileSystem, NDFS32) &&
659 strcmp(FileSystem, HPFS386)) {
660 driveflags[x] |= DRIVE_NOLONGNAMES;
661 }
662
663 if (!strcmp(FileSystem, CDFS) || !strcmp(FileSystem, ISOFS)) {
664 removable = 1;
665 driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOTWRITEABLE | DRIVE_CDROM);
666 }
667 else if (!stricmp(FileSystem, CBSIFS)) {
668 driveflags[x] |= DRIVE_ZIPSTREAM;
669 driveflags[x] &= (~DRIVE_REMOTE);
670 if (drvtype & DRIVE_REMOVABLE)
671 driveflags[x] |= DRIVE_REMOVABLE;
672 if (!(drvtype & DRIVE_NOLONGNAMES))
673 driveflags[x] &= (~DRIVE_NOLONGNAMES);
674 }
675}
676
677VOID FillInDriveFlags(VOID * dummy)
678{
679 ULONG ulDriveNum, ulDriveMap;
680 register INT x;
681
682 for (x = 0; x < 26; x++)
683 driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
684 DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
685 DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS);
686 memset(driveserial, -1, sizeof(driveserial));
687 DosError(FERR_DISABLEHARDERR);
688 DosQCurDisk(&ulDriveNum, &ulDriveMap);
689 for (x = 0; x < 26; x++) {
690 if (ulDriveMap & (1L << x) && !(driveflags[x] & DRIVE_IGNORE)) {
691 {
692 CHAR s[80];
693 ULONG flags = 0, size = sizeof(ULONG);
694
695 sprintf(s, "%c.DriveFlags", (CHAR) (x + 'A'));
696 if (PrfQueryProfileData(fmprof, appname, s, &flags, &size) &&
697 size == sizeof(ULONG))
698 driveflags[x] |= flags;
699 }
700
701 if (x > 1) {
702 if (!(driveflags[x] & DRIVE_NOPRESCAN))
703 DriveFlagsOne(x);
704 else
705 driveserial[x] = -1;
706 }
707 else {
708 driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOLONGNAMES);
709 driveserial[x] = -1;
710 }
711 }
712 else if (!(ulDriveMap & (1L << x)))
713 driveflags[x] |= DRIVE_INVALID;
714 }
715 {
716 ULONG startdrive = 3L;
717
718 DosError(FERR_DISABLEHARDERR);
719 DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
720 (PVOID) & startdrive, (ULONG) sizeof(ULONG));
721 if (startdrive)
722 driveflags[startdrive - 1] |= DRIVE_BOOT;
723 }
724}
725
726CHAR *assign_ignores(CHAR * s)
727{
728 register INT x;
729 register CHAR *p, *pp;
730
731 *s = '/';
732 s[1] = 0;
733 p = s + 1;
734 if (s) {
735 for (x = 0; x < 26; x++) {
736 if ((driveflags[x] & DRIVE_IGNORE) != 0) {
737 *p = (CHAR) x + 'A';
738 p++;
739 *p = 0;
740 }
741 }
742 }
743 if (!s[1]) {
744 *s = 0;
745 pp = s;
746 }
747 else {
748 pp = &s[strlen(s)];
749 *pp = ' ';
750 pp++;
751 }
752 *pp = ';';
753 pp[1] = 0;
754 p = pp + 1;
755 if (pp) {
756 for (x = 0; x < 26; x++) {
757 if ((driveflags[x] & DRIVE_NOPRESCAN) != 0) {
758 *p = (CHAR) x + 'A';
759 p++;
760 *p = 0;
761 }
762 }
763 }
764 if (!pp[1])
765 *pp = 0;
766 pp = &s[strlen(s)];
767 *pp = ' ';
768 pp++;
769 *pp = ',';
770 pp[1] = 0;
771 p = pp + 1;
772 if (pp) {
773 for (x = 0; x < 26; x++) {
774 if ((driveflags[x] & DRIVE_NOLOADICONS) != 0) {
775 *p = (CHAR) x + 'A';
776 p++;
777 *p = 0;
778 }
779 }
780 }
781 if (!pp[1])
782 *pp = 0;
783 pp = &s[strlen(s)];
784 *pp = ' ';
785 pp++;
786 *pp = '-';
787 pp[1] = 0;
788 p = pp + 1;
789 if (pp) {
790 for (x = 0; x < 26; x++) {
791 if ((driveflags[x] & DRIVE_NOLOADSUBJS) != 0) {
792 *p = (CHAR) x + 'A';
793 p++;
794 *p = 0;
795 }
796 }
797 }
798 if (!pp[1])
799 *pp = 0;
800 pp = &s[strlen(s)];
801 *pp = ' ';
802 pp++;
803 *pp = '`';
804 pp[1] = 0;
805 p = pp + 1;
806 if (pp) {
807 for (x = 0; x < 26; x++) {
808 if ((driveflags[x] & DRIVE_NOSTATS) != 0) {
809 *p = (CHAR) x + 'A';
810 p++;
811 *p = 0;
812 }
813 }
814 }
815 if (!pp[1])
816 *pp = 0;
817 pp = &s[strlen(s)];
818 *pp = ' ';
819 pp++;
820 *pp = '\'';
821 pp[1] = 0;
822 p = pp + 1;
823 if (pp) {
824 for (x = 0; x < 26; x++) {
825 if ((driveflags[x] & DRIVE_NOLOADLONGS) != 0) {
826 *p = (CHAR) x + 'A';
827 p++;
828 *p = 0;
829 }
830 }
831 }
832 if (!pp[1])
833 *pp = 0;
834 bstrip(s);
835 return s;
836}
837
838BOOL needs_quoting(register CHAR * f)
839{
840 register CHAR *p = " &|<>";
841
842 while (*p) {
843 if (strchr(f, *p))
844 return TRUE;
845 p++;
846 }
847 return FALSE;
848}
849
850BOOL IsBinary(register CHAR * str, ULONG len)
851{
852 register ULONG x = 0L;
853
854 if (str) {
855 while (x < len) {
856 if (str[x] < ' ' && str[x] != '\r' && str[x] != '\n' && str[x] != '\t'
857 && str[x] != '\x1b' && str[x] != '\x1a' && str[x] != '\07'
858 && str[x] != '\x0c')
859 return TRUE;
860 x++;
861 }
862 }
863 return FALSE;
864}
865
866BOOL TestBinary(CHAR * filename)
867{
868 HFILE handle;
869 ULONG ulAction;
870 ULONG len;
871 APIRET rc;
872 CHAR buff[512];
873
874 if (filename) {
875 if (!DosOpen(filename, &handle, &ulAction, 0L, 0L,
876 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
877 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
878 OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
879 OPEN_ACCESS_READONLY, 0L)) {
880 len = 512;
881 rc = DosRead(handle, buff, len, &len);
882 DosClose(handle);
883 if (!rc && len)
884 return IsBinary(buff, len);
885 }
886 }
887 return FALSE;
888}
889
890char *IsVowel(char a)
891{
892 return (strchr("aeiouAEIOU", a) != NULL) ? "n" : NullStr;
893}
894
895VOID GetDesktopName(CHAR * objectpath, ULONG size)
896{
897 PFN WQDPath;
898 HMODULE hmod = 0;
899 APIRET rc;
900 ULONG startdrive = 3L;
901 CHAR objerr[CCHMAXPATH];
902
903 if (!objectpath) {
904 Runtime_Error(pszSrcFile, __LINE__, "null pointer");
905 return;
906 }
907 *objectpath = 0;
908 if (OS2ver[0] > 20 || (OS2ver[0] == 20 && OS2ver[1] >= 30)) {
909 /*
910 * if running under warp, we can get the desktop name
911 * this way...
912 */
913 rc = DosLoadModule(objerr, sizeof(objerr), "PMWP", &hmod);
914 if (!rc) {
915 rc = DosQueryProcAddr(hmod, 262, NULL, &WQDPath);
916 if (!rc)
917 WQDPath(objectpath, size);
918 DosFreeModule(hmod);
919 }
920 }
921 if (!*objectpath) {
922 // Fall back to INI content
923 if (!PrfQueryProfileString(HINI_SYSTEMPROFILE,
924 "FolderWorkareaRunningObjects",
925 NULL,
926 "\0",
927 (PVOID) objectpath, sizeof(objectpath))) {
928 Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
929 "PrfQueryProfileString");
930 *objectpath = 0;
931 }
932 else if (!*objectpath || IsFile(objectpath)) {
933 Runtime_Error(pszSrcFile, __LINE__, "bad FolderWorkareaRunningObjects");
934 *objectpath = 0;
935 }
936 if (!*objectpath) {
937 // Fall back
938 DosError(FERR_DISABLEHARDERR);
939 DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
940 (PVOID) & startdrive, (ULONG) sizeof(ULONG));
941 sprintf(objectpath, GetPString(IDS_PATHTODESKTOP), ((CHAR) startdrive) + '@');
942 }
943 }
944}
Note: See TracBrowser for help on using the repository browser.