source: trunk/dll/valid.c@ 48

Last change on this file since 48 was 48, checked in by root, 23 years ago

RootName: rework for sanity. MakeFullName: correct typo.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.8 KB
Line 
1
2/***********************************************************************
3
4 $Id: valid.c 48 2003-02-12 20:16:27Z root $
5
6 File name manipulation routines
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2002 Steven H.Levine
10
11 Revisions 23 Nov 02 SHL - RootName: rework for sanity
12 27 Nov 02 SHL - MakeFullName: correct typo
13
14
15***********************************************************************/
16
17#define INCL_DOS
18#define INCL_WIN
19
20#include <os2.h>
21#include <stdlib.h>
22#include <stdio.h>
23#include <string.h>
24#include <ctype.h>
25#include "fm3dll.h"
26
27#pragma alloc_text(VALID,CheckDrive,IsRoot,IsFile,IsFullName,needsquoting)
28#pragma alloc_text(VALID,IsValidDir,IsValidDrive,MakeValidDir,IsVowel)
29#pragma alloc_text(VALID,IsFileSame,IsNewer,TestDates,RootName,MakeFullName)
30#pragma alloc_text(VALID,IsExecutable,IsBinary,IsDesktop,ParentIsDesktop)
31#pragma alloc_text(FILLFLAGS,FillInDriveFlags,assign_ignores)
32#pragma alloc_text(FILLFLAGS,ArgDriveFlags,DriveFlagsOne)
33#pragma alloc_text(FINDDESK,GetDesktopName)
34
35
36APIRET MakeFullName (char *filename) {
37
38 /* filename must be CCHMAXPATH long minimum! */
39
40 char fullname[CCHMAXPATH];
41 APIRET rc;
42
43 DosError(FERR_DISABLEHARDERR);
44 rc = DosQueryPathInfo(filename,
45 FIL_QUERYFULLNAME,
46 fullname,
47 sizeof(fullname));
48 if(!rc)
49 strcpy(filename, fullname); // Use actual name
50 return rc;
51}
52
53
54char *RootName (char *filename) {
55
56 char *p = NULL,*pp;
57
58 // Return filename, strip path parts
59 // Return empty string when filename ends with \
60
61 if(filename) {
62 p = strrchr(filename,'\\');
63 pp = strrchr(filename,'/');
64 p = (p) ?
65 (pp) ?
66 (p > pp) ?
67 p :
68 pp :
69 p :
70 pp;
71 }
72 if(!p) /* name is itself a root */
73 p = filename;
74 else /* skip past backslash */
75 p++;
76 return p;
77}
78
79
80int TestDates (char *file1,char *file2) {
81
82 /*
83 * return 1 (file2 newer than file1),
84 * 0 (files same)
85 * or -1 (file1 newer than file2)
86 */
87
88 int comp = 0;
89 FILESTATUS3 fs3o,fs3n;
90
91 DosError(FERR_DISABLEHARDERR);
92 if(!DosQueryPathInfo(file1,
93 FIL_STANDARD,
94 &fs3o,
95 sizeof(fs3o))) {
96 DosError(FERR_DISABLEHARDERR);
97 if(!DosQueryPathInfo(file2,
98 FIL_STANDARD,
99 &fs3n,
100 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 <
124 fs3o.ftimeLastWrite.twosecs) ? -1 :
125 0;
126 }
127 }
128 return comp;
129}
130
131
132BOOL IsNewer (char *file1,char *file2) {
133
134 /* return TRUE if file2 is newer than file1 */
135
136 return (TestDates(file1,file2) > 0);
137}
138
139
140BOOL IsDesktop (HAB hab,HWND hwnd) {
141
142 HWND hwndDesktop;
143
144 if(hwnd == HWND_DESKTOP)
145 return TRUE;
146 hwndDesktop = WinQueryDesktopWindow(hab,NULLHANDLE);
147 if(hwnd == hwndDesktop)
148 return TRUE;
149 return FALSE;
150}
151
152BOOL ParentIsDesktop (HWND hwnd,HWND hwndParent) {
153
154 HWND hwndDesktop;
155 BOOL ret = FALSE;
156
157 if(!hwndParent)
158 hwndParent = WinQueryWindow(hwnd,QW_PARENT);
159 if(hwndParent == HWND_DESKTOP)
160 ret = TRUE;
161 else {
162 hwndDesktop = WinQueryDesktopWindow(WinQueryAnchorBlock(hwnd),(HWND)0);
163 if(hwndDesktop == hwndParent)
164 ret = TRUE;
165 }
166 return ret;
167}
168
169
170INT CheckDrive (CHAR Drive, CHAR *FileSystem, ULONG *type) {
171
172 CHAR Path[3],*Buffer = NULL,*pfsn = NULL,*pfsd = NULL;
173 ULONG Size,Status,action,LengthIn,LengthOut;
174 HFILE Handle;
175 BYTE Command = 0,NonRemovable;
176 PFSQBUFFER2 pfsq;
177
178 if(FileSystem)
179 *FileSystem = 0;
180 if(type)
181 *type = 0;
182
183 if(DosAllocMem((PVOID)&Buffer,4096,
184 PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE)) {
185 DosBeep(50,50);
186 return -1;
187 }
188
189 Path[0] = Drive;
190 Path[1] = ':';
191 Path[2] = 0;
192 Size = 4096;
193 DosError(FERR_DISABLEHARDERR);
194 Status = DosQueryFSAttach(Path, 0, FSAIL_QUERYNAME,
195 (PFSQBUFFER2)Buffer, &Size);
196 if(Status) { /* can't get any info at all */
197 DosFreeMem(Buffer);
198 DosError(FERR_DISABLEHARDERR);
199 return -1;
200 }
201
202 pfsq = (PFSQBUFFER2)Buffer;
203 pfsn = pfsq->szName + pfsq->cbName + 1;
204 pfsd = pfsn + pfsq->cbFSDName + 1;
205
206 if(FileSystem) {
207 strncpy(FileSystem, pfsn, CCHMAXPATH);
208 FileSystem[CCHMAXPATH - 1] = 0;
209 }
210
211 if(type && !strcmp(pfsn,CDFS))
212 (*type) |= (DRIVE_NOTWRITEABLE | DRIVE_CDROM | DRIVE_REMOVABLE);
213
214 if(((PFSQBUFFER2)Buffer)->iType == FSAT_REMOTEDRV) {
215 if(type)
216 (*type) |= DRIVE_REMOTE;
217 if(type && !strcmp(pfsn,CBSIFS)) {
218 (*type) |= DRIVE_ZIPSTREAM;
219 (*type) &= (~DRIVE_REMOTE);
220 (*type) |= DRIVE_NOLONGNAMES;
221 if(pfsq->cbFSAData) {
222
223 ULONG FType;
224
225 if(CheckDrive(*pfsd,NULL,&FType) != -1) {
226 if(FType & DRIVE_REMOVABLE)
227 (*type) |= DRIVE_REMOVABLE;
228 if(!(FType & DRIVE_NOLONGNAMES))
229 (*type) &= (~DRIVE_NOLONGNAMES);
230 }
231 }
232 }
233 if(type && (!strcmp(pfsn,HPFS) || !strcmp(pfsn,HPFS386)))
234 (*type) &= (~DRIVE_NOLONGNAMES);
235 DosFreeMem(Buffer);
236 return 0; /* assume remotes are non-removable */
237 }
238
239 if(strcmp(pfsn,HPFS) && strcmp(pfsn,CDFS) && strcmp(pfsn,HPFS386)) {
240 if(type)
241 (*type) |= DRIVE_NOLONGNAMES;
242 }
243
244 DosError(FERR_DISABLEHARDERR);
245 Status = DosOpen(Path, &Handle, &action, 0, 0, FILE_OPEN,
246 OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE |
247 OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR, 0);
248 if(Status) {
249 DosError(FERR_DISABLEHARDERR);
250 if(type)
251 (*type) |= DRIVE_REMOVABLE;
252 DosFreeMem(Buffer);
253 return(1); /* assume inaccessible local drives are removable */
254 }
255 LengthIn = sizeof(Command);
256 LengthOut = sizeof(NonRemovable);
257 NonRemovable = 1;
258 DosError(FERR_DISABLEHARDERR);
259 DosDevIOCtl(Handle, 8, 0x20,&Command, sizeof(Command), &LengthIn,
260 &NonRemovable, sizeof(NonRemovable), &LengthOut);
261 DosClose(Handle);
262 if(!NonRemovable && type)
263 (*type) |= DRIVE_REMOVABLE;
264 DosFreeMem(Buffer);
265 return (NonRemovable) ? 0 : 1;
266}
267
268
269BOOL IsFileSame (CHAR *filename1,CHAR *filename2) {
270
271 /* returns: -1 (error), 0 (is a directory), or 1 (is a file) */
272
273 FILESTATUS3 fsa1,fsa2;
274 APIRET ret;
275
276 if(filename1 && filename2) {
277 DosError(FERR_DISABLEHARDERR);
278 ret = DosQueryPathInfo(filename1,FIL_STANDARD,&fsa1,
279 (ULONG)sizeof(fsa1));
280 if(!ret) {
281 DosError(FERR_DISABLEHARDERR);
282 ret = DosQueryPathInfo(filename2,FIL_STANDARD,&fsa2,
283 (ULONG)sizeof(fsa2));
284 if(!ret) {
285 if(fsa1.cbFile == fsa2.cbFile &&
286 (fsa1.attrFile & (~FILE_ARCHIVED)) ==
287 (fsa2.attrFile & (~FILE_ARCHIVED)))
288 return TRUE;
289 }
290 }
291 }
292 return FALSE;
293}
294
295
296INT IsFile (CHAR *filename) {
297
298 /* returns: -1 (error), 0 (is a directory), or 1 (is a file) */
299
300 FILESTATUS3 fsa;
301 APIRET ret;
302
303 if(filename && *filename) {
304 DosError(FERR_DISABLEHARDERR);
305 ret = DosQueryPathInfo(filename,
306 FIL_STANDARD,
307 &fsa,
308 (ULONG)sizeof(fsa));
309 if(!ret)
310 return ((fsa.attrFile & FILE_DIRECTORY) == 0);
311 else if(IsValidDrive(*filename) && IsRoot(filename))
312 return 0;
313 }
314 return -1; /* error; doesn't exist or can't read or null filename */
315}
316
317
318BOOL IsFullName (CHAR *filename) {
319
320 return (filename) ?
321 (isalpha(*filename) && filename[1] == ':' && filename[2] == '\\') :
322 0;
323}
324
325
326BOOL IsRoot (CHAR *filename) {
327
328 return (filename && isalpha(*filename) && filename[1] == ':' &&
329 filename[2] == '\\' && !filename[3]);
330}
331
332
333BOOL IsValidDir (CHAR *path) {
334
335 CHAR fullname[CCHMAXPATH];
336 FILESTATUS3 fs;
337
338 if(path) {
339 DosError(FERR_DISABLEHARDERR);
340 if(!DosQueryPathInfo(path,
341 FIL_QUERYFULLNAME,
342 fullname,
343 sizeof(fullname))) {
344 if(IsValidDrive(*fullname)) {
345 if(!IsRoot(fullname)) {
346 DosError(FERR_DISABLEHARDERR);
347 if(!DosQueryPathInfo(fullname,
348 FIL_STANDARD,
349 &fs,
350 sizeof(fs)) &&
351 (fs.attrFile & FILE_DIRECTORY))
352 return TRUE;
353 }
354 else
355 return TRUE;
356 }
357 }
358 }
359 return FALSE;
360}
361
362
363BOOL IsValidDrive (CHAR drive) {
364
365 CHAR Path[] = " :",Buffer[256];
366 APIRET Status;
367 ULONG Size;
368 ULONG ulDriveNum,ulDriveMap;
369
370 if(!isalpha(drive) ||
371 (driveflags[toupper(drive) - 'A'] & (DRIVE_IGNORE | DRIVE_INVALID)))
372 return FALSE;
373 DosError(FERR_DISABLEHARDERR);
374 Status = DosQCurDisk(&ulDriveNum,&ulDriveMap);
375 if(!Status) {
376 if(!(ulDriveMap & (1L << (ULONG)(toupper(drive) - 'A'))))
377 return FALSE;
378 Path[0] = toupper(drive);
379 Size = sizeof(Buffer);
380 DosError(FERR_DISABLEHARDERR);
381 Status = DosQueryFSAttach(Path,
382 0,
383 FSAIL_QUERYNAME,
384 (PFSQBUFFER2)Buffer,
385 &Size);
386 }
387 return (Status == 0);
388}
389
390
391CHAR * MakeValidDir (CHAR *path) {
392
393 CHAR fullname[CCHMAXPATH],drive;
394 register CHAR *p;
395 FILESTATUS3 fs;
396 APIRET status;
397
398 if(!MakeFullName(path)) {
399 if(IsValidDrive(*path)) {
400 for(;;) {
401 if(IsRoot(path))
402 return path;
403 DosError(FERR_DISABLEHARDERR);
404 status = DosQueryPathInfo(path,
405 FIL_STANDARD,
406 &fs,
407 sizeof(fs));
408 if(!status &&
409 (fs.attrFile & FILE_DIRECTORY) != 0)
410 return path;
411 p = strrchr(path,'\\');
412 if(p) {
413 if(p < path + 3)
414 p++;
415 *p = 0;
416 }
417 else
418 break;
419 }
420 }
421 }
422 DosError(FERR_DISABLEHARDERR);
423 if(!DosQuerySysInfo(QSV_BOOT_DRIVE,
424 QSV_BOOT_DRIVE,
425 &drive,
426 1L)) {
427 drive += '@';
428 if(drive < 'C')
429 drive = 'C';
430 strcpy(path," :\\");
431 *path = drive;
432 }
433 else
434 save_dir2(path);
435 return path;
436}
437
438
439BOOL IsExecutable (CHAR *filename) {
440
441 register CHAR *p;
442 APIRET ret;
443 ULONG apptype;
444
445 if(filename) {
446 DosError(FERR_DISABLEHARDERR);
447 p = strrchr(filename,'.');
448 if(p)
449 ret = DosQAppType(filename,
450 &apptype);
451 else {
452
453 char fname[CCHMAXPATH + 2];
454
455 strcpy(fname,filename);
456 strcat(fname,".");
457 ret = DosQAppType(fname,
458 &apptype);
459 }
460 if((!ret && (!apptype ||
461 (apptype &
462 (FAPPTYP_NOTWINDOWCOMPAT |
463 FAPPTYP_WINDOWCOMPAT |
464 FAPPTYP_WINDOWAPI |
465 FAPPTYP_BOUND |
466 FAPPTYP_DOS |
467 FAPPTYP_WINDOWSREAL |
468 FAPPTYP_WINDOWSPROT |
469 FAPPTYP_32BIT |
470 0x1000)))) ||
471 (p &&
472 (!stricmp(p,".CMD") ||
473 !stricmp(p,".BAT"))))
474 return TRUE;
475 }
476 return FALSE;
477}
478
479
480VOID ArgDriveFlags (INT argc,CHAR **argv) {
481
482 INT x;
483
484 for(x = 1;x < argc;x++) {
485 if(*argv[x] == '/' && isalpha(argv[x][1])) {
486
487 CHAR *p = &argv[x][1];
488
489 while(isalpha(*p)) {
490 driveflags[toupper(*p) - 'A'] |= DRIVE_IGNORE;
491 p++;
492 }
493 }
494 else if(*argv[x] == ';' && isalpha(argv[x][1])) {
495
496 CHAR *p = &argv[x][1];
497
498 while(isalpha(*p)) {
499 driveflags[toupper(*p) - 'A'] |= DRIVE_NOPRESCAN;
500 p++;
501 }
502 }
503 else if(*argv[x] == ',' && isalpha(argv[x][1])) {
504
505 CHAR *p = &argv[x][1];
506
507 while(isalpha(*p)) {
508 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADICONS;
509 p++;
510 }
511 }
512 else if(*argv[x] == '`' && isalpha(argv[x][1])) {
513
514 CHAR *p = &argv[x][1];
515
516 while(isalpha(*p)) {
517 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADSUBJS;
518 p++;
519 }
520 }
521 else if(*argv[x] == '\'' && isalpha(argv[x][1])) {
522
523 CHAR *p = &argv[x][1];
524
525 while(isalpha(*p)) {
526 driveflags[toupper(*p) - 'A'] |= DRIVE_NOLOADLONGS;
527 p++;
528 }
529 }
530 }
531}
532
533
534VOID DriveFlagsOne (INT x) {
535
536 INT removable;
537 CHAR szDrive[] = " :\\",FileSystem[CCHMAXPATH];
538 ULONG drvtype;
539
540 *szDrive = (CHAR)(x + 'A');
541 *FileSystem = 0;
542 drvtype = 0;
543 removable = CheckDrive(*szDrive,FileSystem,&drvtype);
544 driveserial[x] = -1;
545 driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
546 DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
547 DRIVE_INCLUDEFILES | DRIVE_SLOW);
548 if(removable != -1) {
549
550 struct {
551 ULONG serial;
552 CHAR volumelength;
553 CHAR volumelabel[CCHMAXPATH];
554 } volser;
555
556 DosError(FERR_DISABLEHARDERR);
557 if(!DosQueryFSInfo((ULONG)x + 1,FSIL_VOLSER,&volser,sizeof(volser)))
558 driveserial[x] = volser.serial;
559 else
560 DosError(FERR_DISABLEHARDERR);
561 }
562 else
563 driveflags[x] |= DRIVE_INVALID;
564 driveflags[x] |= ((removable == -1 || removable == 1) ?
565 DRIVE_REMOVABLE : 0);
566 if(drvtype & DRIVE_REMOTE)
567 driveflags[x] |= DRIVE_REMOTE;
568 if(strcmp(FileSystem,HPFS) &&
569 strcmp(FileSystem,HPFS386) &&
570 strcmp(FileSystem,CDFS))
571 driveflags[x] |= DRIVE_NOLONGNAMES;
572 if(!strcmp(FileSystem,CDFS)) {
573 removable = 1;
574 driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOTWRITEABLE |
575 DRIVE_CDROM);
576 }
577 else if(!stricmp(FileSystem,CBSIFS)) {
578 driveflags[x] |= DRIVE_ZIPSTREAM;
579 driveflags[x] &= (~DRIVE_REMOTE);
580 if(drvtype & DRIVE_REMOVABLE)
581 driveflags[x] |= DRIVE_REMOVABLE;
582 if(!(drvtype & DRIVE_NOLONGNAMES))
583 driveflags[x] &= (~DRIVE_NOLONGNAMES);
584 }
585}
586
587
588VOID FillInDriveFlags (VOID *dummy) {
589
590 ULONG ulDriveNum,ulDriveMap;
591 register INT x;
592
593 for(x = 0;x < 26;x++)
594 driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
595 DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
596 DRIVE_INCLUDEFILES | DRIVE_SLOW);
597 memset(driveserial,-1,sizeof(driveserial));
598 DosError(FERR_DISABLEHARDERR);
599 DosQCurDisk(&ulDriveNum,&ulDriveMap);
600 for(x = 0;x < 26;x++) {
601 if(ulDriveMap & (1L << x) && !(driveflags[x] & DRIVE_IGNORE)) {
602 {
603 CHAR s[80];
604 ULONG flags = 0,size = sizeof(ULONG);
605
606 sprintf(s,"%c.DriveFlags",(CHAR)(x + 'A'));
607 if(PrfQueryProfileData(fmprof,appname,s,&flags,&size) &&
608 size == sizeof(ULONG))
609 driveflags[x] |= flags;
610 }
611
612 if(x > 1) {
613 if(!(driveflags[x] & DRIVE_NOPRESCAN))
614 DriveFlagsOne(x);
615 else
616 driveserial[x] = -1;
617 }
618 else {
619 driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOLONGNAMES);
620 driveserial[x] = -1;
621 }
622 }
623 else if(!(ulDriveMap & (1L << x)))
624 driveflags[x] |= DRIVE_INVALID;
625 }
626 {
627 ULONG startdrive = 3L;
628
629 DosError(FERR_DISABLEHARDERR);
630 DosQuerySysInfo(QSV_BOOT_DRIVE,QSV_BOOT_DRIVE,
631 (PVOID)&startdrive,(ULONG)sizeof(ULONG));
632 if(startdrive)
633 driveflags[startdrive - 1] |= DRIVE_BOOT;
634 }
635}
636
637
638CHAR * assign_ignores (CHAR *s) {
639
640 register INT x;
641 register CHAR *p,*pp;
642
643 *s = '/';
644 s[1] = 0;
645 p = s + 1;
646 if(s) {
647 for(x = 0;x < 26;x++) {
648 if((driveflags[x] & DRIVE_IGNORE) != 0) {
649 *p = (CHAR)x + 'A';
650 p++;
651 *p = 0;
652 }
653 }
654 }
655 if(!s[1]) {
656 *s = 0;
657 pp = s;
658 }
659 else {
660 pp = &s[strlen(s)];
661 *pp = ' ';
662 pp++;
663 }
664 *pp = ';';
665 pp[1] = 0;
666 p = pp + 1;
667 if(pp) {
668 for(x = 0;x < 26;x++) {
669 if((driveflags[x] & DRIVE_NOPRESCAN) != 0) {
670 *p = (CHAR)x + 'A';
671 p++;
672 *p = 0;
673 }
674 }
675 }
676 if(!pp[1])
677 *pp = 0;
678 pp = &s[strlen(s)];
679 *pp = ' ';
680 pp++;
681 *pp = ',';
682 pp[1] = 0;
683 p = pp + 1;
684 if(pp) {
685 for(x = 0;x < 26;x++) {
686 if((driveflags[x] & DRIVE_NOLOADICONS) != 0) {
687 *p = (CHAR)x + 'A';
688 p++;
689 *p = 0;
690 }
691 }
692 }
693 if(!pp[1])
694 *pp = 0;
695 pp = &s[strlen(s)];
696 *pp = ' ';
697 pp++;
698 *pp = '`';
699 pp[1] = 0;
700 p = pp + 1;
701 if(pp) {
702 for(x = 0;x < 26;x++) {
703 if((driveflags[x] & DRIVE_NOLOADSUBJS) != 0) {
704 *p = (CHAR)x + 'A';
705 p++;
706 *p = 0;
707 }
708 }
709 }
710 if(!pp[1])
711 *pp = 0;
712 pp = &s[strlen(s)];
713 *pp = ' ';
714 pp++;
715 *pp = '\'';
716 pp[1] = 0;
717 p = pp + 1;
718 if(pp) {
719 for(x = 0;x < 26;x++) {
720 if((driveflags[x] & DRIVE_NOLOADLONGS) != 0) {
721 *p = (CHAR)x + 'A';
722 p++;
723 *p = 0;
724 }
725 }
726 }
727 if(!pp[1])
728 *pp = 0;
729 lstrip(rstrip(s));
730 return s;
731}
732
733
734BOOL needs_quoting (register CHAR *f) {
735
736 register CHAR *p = " &|<>";
737
738 while(*p) {
739 if(strchr(f,*p))
740 return TRUE;
741 p++;
742 }
743 return FALSE;
744}
745
746
747BOOL IsBinary (register CHAR *str,ULONG len) {
748
749 register ULONG x = 0L;
750
751 if(str) {
752 while(x < len) {
753 if(str[x] < ' ' && str[x] != '\r' && str[x] != '\n' && str[x] != '\t' &&
754 str[x] != '\x1b' && str[x] != '\x1a' && str[x] != '\07' &&
755 str[x] != '\x0c')
756 return TRUE;
757 x++;
758 }
759 }
760 return FALSE;
761}
762
763
764BOOL TestBinary (CHAR *filename) {
765
766 HFILE handle;
767 ULONG action,len;
768 APIRET rc;
769 CHAR buff[512];
770
771 if(filename) {
772 if(!DosOpen(filename,&handle,&action,0L,0L,
773 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
774 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
775 OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
776 OPEN_ACCESS_READONLY,0L)) {
777 len = 512;
778 rc = DosRead(handle,buff,len,&len);
779 DosClose(handle);
780 if(!rc && len)
781 return IsBinary(buff,len);
782 }
783 }
784 return FALSE;
785}
786
787
788char *IsVowel (char a) {
789
790 return (strchr("aeiouAEIOU",a) != NULL) ? "n" : NullStr;
791}
792
793
794VOID GetDesktopName (CHAR *objectpath,ULONG size) {
795
796 PFN WQDPath;
797 HMODULE hmod = 0;
798 APIRET rc;
799 ULONG startdrive = 3L;
800 CHAR objerr[CCHMAXPATH];
801
802 if(!objectpath)
803 return;
804 *objectpath = 0;
805 if(OS2ver[0] > 20 || (OS2ver[0] == 20 && OS2ver[1] >= 30)) {
806 /*
807 * if running under warp, we can get the desktop name
808 * this way...
809 */
810 rc = DosLoadModule(objerr,
811 sizeof(objerr),
812 "PMWP",
813 &hmod);
814 if(!rc) {
815 rc = DosQueryProcAddr(hmod,
816 262,
817 NULL,
818 &WQDPath);
819 if(!rc)
820 WQDPath(objectpath,size);
821 DosFreeModule(hmod);
822 }
823 }
824 if(!*objectpath) {
825 if(!PrfQueryProfileString(HINI_SYSTEMPROFILE,
826 "FolderWorkareaRunningObjects",
827 NULL,
828 "\0",
829 (PVOID)objectpath,
830 sizeof(objectpath)))
831 *objectpath = 0;
832 if(!*objectpath || IsFile(objectpath)) {
833 DosBeep(250,10);
834 DosError(FERR_DISABLEHARDERR);
835 DosQuerySysInfo(QSV_BOOT_DRIVE,QSV_BOOT_DRIVE,
836 (PVOID)&startdrive,(ULONG)sizeof(ULONG));
837 sprintf(objectpath,
838 "%c:\\DESKTOP",
839 ((CHAR)startdrive) + '@');
840 }
841 }
842}
Note: See TracBrowser for help on using the repository browser.