source: trunk/dll/valid.c @ 766

Last change on this file since 766 was 766, checked in by Gregg Young, 13 years ago

format cleanup

  • 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 766 2007-08-05 20:21:20Z gyoung $
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 & (1 << (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 & (1 << 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 & (1 << 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 = 0;
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, 0, 0,
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, 0)) {
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 = 3;
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.