source: trunk/dll/copyf.c@ 193

Last change on this file since 193 was 173, checked in by root, 20 years ago

Drop debug code
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.0 KB
RevLine 
[29]1
2/***********************************************************************
3
4 $Id: copyf.c 173 2005-05-28 17:34:46Z root $
5
6 Copy functions
7
8 Copyright (c) 1993-98 M. Kimes
[173]9 Copyright (c) 2001, 2005 Steven H.Levine
[29]10
[173]11 14 Sep 02 SHL Drop obsolete debug code
12 14 Oct 02 SHL Drop obsolete debug code
13 10 Nov 02 SHL docopyf - don't forget to terminate longname
14 optimize longname logic
15 01 Aug 04 SHL Rework lstrip/rstrip usage
16 28 May 05 SHL Drop debug code
[29]17
18***********************************************************************/
19
[2]20#define INCL_DOS
21#define INCL_DOSERRORS
22#define INCL_WIN
23
24#include <os2.h>
25#include <io.h>
26#include <string.h>
27#include <stdlib.h>
28#include <stdio.h>
29#include <stdarg.h>
30#include <ctype.h>
31#include <time.h>
32#include "fm3dll.h"
33
34#ifndef WinMoveObject
35 HOBJECT APIENTRY WinMoveObject(HOBJECT hObjectofObject,
36 HOBJECT hObjectofDest,
37 ULONG ulReserved);
38#endif
39#ifndef WinCopyObject
40 HOBJECT APIENTRY WinCopyObject(HOBJECT hObjectofObject,
41 HOBJECT hObjectofDest,
42 ULONG ulReserved);
43#endif
44
45#pragma alloc_text(LONGNAMES,TruncName,GetLongName,WriteLongName)
46#pragma alloc_text(LONGNAMES,ZapLongName,AdjustWildcardName)
47#pragma alloc_text(COPYF,default_disk,docopyf)
48#pragma alloc_text(UNLINKF,unlinkf,unlink_allf,make_deleteable,wipeallf)
49
50
51char *MakeTempName (char *buffer) {
52
53 FILESTATUS3 fs3;
54 APIRET rc;
55 char *p,*o;
56
57 p = o = buffer + strlen(buffer);
58 sprintf(p,"%08lx.%03lx",clock(),mypid);
59 p = buffer + (strlen(buffer) - 1);
60 for(;;) {
61 DosError(FERR_DISABLEHARDERR);
62 rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
63 (ULONG)sizeof(fs3));
64 if(rc == ERROR_DISK_CHANGE) {
65 DosError(FERR_ENABLEHARDERR);
66 rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
67 (ULONG)sizeof(fs3));
68 }
69 if(rc)
70 break;
71Loop:
72 if(p < o) {
73 *buffer = 0;
74 return NULL;
75 }
76 if((*p) + 1 < 'Z' + 1) {
77 (*p)++;
78 while(strchr("*?<>\":/\\|+=;,[]. ",*p))
79 (*p)++;
80 *p = toupper(*p);
81 }
82 else {
83 p--;
84 if(p >= o && *p == '.')
85 p--;
86 goto Loop;
87 }
88 }
89 return buffer;
90}
91
92
93CHAR *TruncName (CHAR *oldname,CHAR *buffer) {
94
95 CHAR *p,*f,*s,*o;
96 FILESTATUS3 fs3;
97 APIRET rc;
98
99 if(!buffer || !oldname || !*oldname) {
100 if(buffer)
101 *buffer = 0;
102 return NULL;
103 }
104 strcpy(buffer,oldname);
105 f = strrchr(buffer,'\\');
106 if(!f)
107 f = strrchr(buffer,'/');
108 if(!f)
109 f = buffer;
110 else
111 f++;
112 p = f;
113 o = p;
114 f = oldname + (f - buffer);
115 strupr(buffer);
116 while(*f == '.') /* skip leading '.'s */
117 f++;
118 s = f;
119 while(*f && *f != '.' && f < s + 8) { /* skip past rootname */
120 *p = toupper(*f);
121 p++;
122 f++;
123 }
124 while(*f == '.')
125 f++;
126 s = f;
127 f = strrchr(f,'.');
128 if(f) {
129 while(*f == '.')
130 f++;
131 }
132 if(f && *(f + 1))
133 s = f;
134 else
135 f = s;
136 if(*f) {
137 *p = '.';
138 p++;
139 while(*f && *f != '.' && f < s + 3) {
140 *p = toupper(*f);
141 p++;
142 f++;
143 }
144 }
145 *p = 0;
146
147 p = o;
148 while(*p) {
149 if(strchr("*?<>\":/\\|+=;,[] ",*p) || *p < 0x20)
150 *p = '_';
151 if(*p == '.' && *(p + 1) == '.')
152 *(p + 1) = '_';
153 p++;
154 }
155
156 p = o + (strlen(o) - 1);
157 for(;;) {
158 DosError(FERR_DISABLEHARDERR);
159 rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
160 (ULONG)sizeof(fs3));
161 if(rc == ERROR_DISK_CHANGE) {
162 DosError(FERR_ENABLEHARDERR);
163 rc = DosQueryPathInfo(buffer,FIL_STANDARD,&fs3,
164 (ULONG)sizeof(fs3));
165 }
166 if(rc)
167 break;
168Loop:
169 if(p < o) {
170 *buffer = 0;
171 return NULL;
172 }
173 if((*p) + 1 < 'Z' + 1) {
174 (*p)++;
175 while(strchr("*?<>\":/\\|+=;,[]. ",*p))
176 (*p)++;
177 *p = toupper(*p);
178 }
179 else {
180 p--;
181 if(p >= o && *p == '.')
182 p--;
183 goto Loop;
184 }
185 }
186 return buffer;
187}
188
189
190CHAR *GetLongName (CHAR *oldname,CHAR *longname) {
191
192 if(!longname)
193 return NULL;
194 *longname = 0;
195 if(!oldname ||
196 !*oldname)
197 return NULL;
198 if(IsFullName(oldname)) {
199
200 APIRET rc;
201 EAOP2 eaop;
202 PGEA2LIST pgealist;
203 PFEA2LIST pfealist;
204 PGEA2 pgea;
205 PFEA2 pfea;
206 CHAR *value;
207
208 strcpy(longname,
209 oldname);
210 value = longname;
211 while(*value) {
212 if(*value == '/')
213 *value = '\\';
214 value++;
215 }
216 value = strrchr(longname,'\\');
217 if(value) {
218 value++;
219 *value = 0;
220 }
221 pgealist = malloc(sizeof(GEA2LIST) + 32);
222 if(pgealist) {
223 memset(pgealist,0,sizeof(GEA2LIST) + 32);
224 pgea = &pgealist->list[0];
225 strcpy(pgea->szName,LONGNAME);
226 pgea->cbName = strlen(pgea->szName);
227 pgea->oNextEntryOffset = 0L;
228 pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
229 pfealist = malloc(1536);
230 if(pfealist) {
231 memset(pfealist,0,1024);
232 pfealist->cbList = 1024;
233 eaop.fpGEA2List = pgealist;
234 eaop.fpFEA2List = pfealist;
235 eaop.oError = 0L;
236 DosError(FERR_DISABLEHARDERR);
237 rc = DosQueryPathInfo(oldname,
238 FIL_QUERYEASFROMLIST,
239 (PVOID)&eaop,
240 (ULONG)sizeof(EAOP2));
241 if(!rc) {
242 pfea = &eaop.fpFEA2List->list[0];
243 value = pfea->szName + pfea->cbName + 1;
244 value[pfea->cbValue] = 0;
245 if(*(USHORT *)value == EAT_ASCII)
246 strncat(longname,
247 value + (sizeof(USHORT) * 2),
248 CCHMAXPATH - strlen(longname));
249 longname[CCHMAXPATH - 1] = 0;
250 }
251 free(pfealist);
252 }
253 free(pgealist);
254 }
255 }
256 return longname;
257}
258
259
260BOOL ZapLongName (char *filename) {
261
[29]262 return WriteLongName(filename, "");
[2]263}
264
265
266BOOL WriteLongName (CHAR *filename,CHAR *longname) {
267
268 APIRET rc;
269 EAOP2 eaop;
270 PFEA2LIST pfealist = NULL;
271 ULONG ealen;
272 USHORT len;
273 CHAR *eaval,*p;
274
275 if(!filename ||
276 !*filename ||
277 !longname)
278 return FALSE;
279 p = strrchr(longname,'\\');
280 if(p)
281 memmove(longname,
282 p + 1,
283 strlen(p + 1) + 1);
284 p = strrchr(longname,'/');
285 if(p)
286 memmove(longname,
287 p + 1,
288 strlen(p + 1) + 1);
[123]289 bstrip(longname);
[2]290 len = strlen(longname);
291 if(len)
292 ealen = sizeof(FEA2LIST) + 10 + len + 4;
293 else
294 ealen = sizeof(FEALIST) + 10;
295 if(!DosAllocMem((PPVOID)&pfealist,
296 ealen + 32L,
297 OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE)) {
298 memset(pfealist,
299 0,
300 ealen + 1);
301 pfealist->cbList = ealen;
302 pfealist->list[0].oNextEntryOffset = 0L;
303 pfealist->list[0].fEA = 0;
304 pfealist->list[0].cbName = 9;
305 strcpy(pfealist->list[0].szName,
306 LONGNAME);
307 if(len) {
308 eaval = pfealist->list[0].szName + 10;
309 *(USHORT *)eaval = (USHORT)EAT_ASCII;
310 eaval += sizeof(USHORT);
311 *(USHORT *)eaval = (USHORT)len;
312 eaval += sizeof(USHORT);
313 memcpy(eaval,
314 longname,
315 len);
316 pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2);
317 }
318 else
319 pfealist->list[0].cbValue = 0;
320 eaop.fpGEA2List = (PGEA2LIST)0;
321 eaop.fpFEA2List = pfealist;
322 eaop.oError = 0L;
323 DosError(FERR_DISABLEHARDERR);
324 rc = DosSetPathInfo(filename,
325 FIL_QUERYEASIZE,
326 (PVOID)&eaop,
327 (ULONG)sizeof(EAOP2),
328 DSPI_WRTTHRU);
329 DosFreeMem(pfealist);
330 if(rc)
331 return FALSE;
332 }
333 return TRUE;
334}
335
336
337BOOL AdjustWildcardName (CHAR *oldname,CHAR *newname) {
338
339 BOOL ret = FALSE;
340
341 /* NOTE: newname should be CCHMAXPATH chars long! */
342
343 if(strchr(newname,'*') || strchr(newname,'?')) {
344
345 CHAR srce[CCHMAXPATHCOMP],dest[CCHMAXPATHCOMP],result[CCHMAXPATHCOMP],*p;
346
347 p = strrchr(newname,'\\');
348 if(p && *(p + 1)) {
349 strcpy(dest,p + 1);
350 p = strrchr(oldname,'\\');
351 if(p && *(p + 1)) {
352 strcpy(srce,p + 1);
353 DosError(FERR_DISABLEHARDERR);
354 if(!DosEditName(1L,srce,dest,result,(ULONG)sizeof(result))) {
355 p = strrchr(newname,'\\');
356 p++;
357 strcpy(p,result);
358 ret = TRUE;
359 }
360 }
361 }
362 }
363 return ret;
364}
365
366
367CHAR default_disk (VOID) {
368
369 ULONG ulDriveNum,ulDriveMap;
370
371 DosError(FERR_DISABLEHARDERR);
372 DosQCurDisk(&ulDriveNum,&ulDriveMap);
373 return (CHAR)toupper((INT)ulDriveNum) + '@';
374}
375
376
377#ifdef NEVER
378
379APIRET docopyallf (INT type,CHAR *oldname,CHAR *newname,...) {
380
381 FILEFINDBUF3 fb;
382 ULONG nm;
383 HDIR hdir;
384 APIRET rc = 0;
385 CHAR *enddir,fullname[CCHMAXPATH];
386
387 va_start(ap,newname);
388 vsprintf(fullname,newname,ap);
389 va_end(ap);
390
391 DosError(FERR_DISABLEHARDERR);
392 if(!DosFindFirst(oldname)) {
393 do {
394
395 /* build target name */
396
397 if(fb.attrFile & FILE_DIRECTORY) {
398 DosError(FERR_ENABLEHARDERR);
399 rc = DosCreateDir();
400 if(rc == ERROR_INVALID_NAME || rc == ERROR_FILENAME_EXCED_RANGE) {
401
402 /* truncate directory name */
403 /* create that directory */
404 /* update containers for name used */
405
406 }
407 rc = docopyallf(type,,"%s",); /* recurse */
408 }
409 else
410 rc = docopyf(type,,"%s",); /* copy file */
411 DosError(FERR_DISABLEHARDERR);
412 } while(!rc && !DosFindNext());
413 DosFindClose(hdir);
414 }
415 else
416 rc = ERROR_FILE_NOT_FOUND;
417 return rc;
418}
419
420#endif
421
422
423APIRET docopyf (INT type,CHAR *oldname,CHAR *newname,...) {
424
425 /*
426 * returns:
427 * 0: success
428 * -1: bad string parameter(s)
429 * -2: source didn't exist
430 * -3: bad type
431 * anything else: API return
432 */
433
434 CHAR fullnewname[CCHMAXPATH + 1],longname[CCHMAXPATH],
435 shortname[CCHMAXPATH];
436 CHAR olddisk,newdisk,dir[CCHMAXPATH],*p,*pp;
437 APIRET ret = -1,rc;
438 FILESTATUS3 st,st2,dummy;
439 BOOL diskchange = FALSE,zaplong = FALSE;
440 va_list ap;
441
[45]442 *fullnewname = *shortname = *dir = 0;
[2]443
444 va_start(ap,
445 newname);
446 vsprintf(fullnewname,
447 newname,
448 ap);
449 va_end(ap);
450
451 if(!oldname ||
452 !*oldname ||
453 !*fullnewname) /* bad string args */
454 return (APIRET)-1;
[29]455
[2]456 DosError(FERR_DISABLEHARDERR);
457 if(DosQueryPathInfo(oldname,
458 FIL_STANDARD,
459 &st,
460 sizeof(FILESTATUS3)))
[29]461 return (APIRET)-2; /* no source */
462
[2]463 AdjustWildcardName(oldname,
464 fullnewname);
465 MakeFullName(oldname);
466 MakeFullName(fullnewname);
467 olddisk = toupper(*oldname); /* source drive */
468 newdisk = toupper(*fullnewname); /* destination drive */
[45]469 if(!(driveflags[toupper(*oldname) - 'A'] & DRIVE_NOLONGNAMES))
470 *longname = 0;
471 else
472 {
473 GetLongName(oldname, longname);
474 if(*longname) {
[2]475 p = RootName(longname);
476 if(p != longname)
[45]477 memmove(longname, p, strlen(p) + 1);
[2]478 }
[45]479 }
480 /* If root name changed make sure longname EA goes away */
481 p = RootName(oldname);
482 pp = RootName(fullnewname);
483 if(stricmp(p, pp))
484 {
485 zaplong = TRUE;
[2]486 }
487
488 DosError(FERR_DISABLEHARDERR);
[29]489 switch(type)
490 {
[2]491 case WPSMOVE:
492 {
493 HOBJECT hobjsrc;
494 HOBJECT hobjdest;
495
496 ret = ERROR_FILE_NOT_FOUND;
497 hobjsrc = WinQueryObject(oldname);
498 if(hobjsrc) {
499 strcpy(dir,
500 fullnewname);
501 p = strrchr(dir,'\\');
502 if(p < dir + 3)
503 p++;
504 *p = 0;
505 ret = ERROR_PATH_NOT_FOUND;
506 hobjdest = WinQueryObject(dir);
507 if(hobjdest) {
508 ret = ERROR_GEN_FAILURE;
509 hobjsrc = WinMoveObject(hobjsrc,
510 hobjdest,
511 0);
512 if(hobjsrc)
513 ret = 0;
514 }
515 }
516 }
517 return ret;
518
519 case WPSCOPY:
520 {
521 HOBJECT hobjsrc;
522 HOBJECT hobjdest;
523
524 ret = ERROR_FILE_NOT_FOUND;
525 hobjsrc = WinQueryObject(oldname);
526 if(hobjsrc) {
527 strcpy(dir,
528 fullnewname);
529 p = strrchr(dir,'\\');
530 if(p < dir + 3)
531 p++;
532 *p = 0;
533 ret = ERROR_PATH_NOT_FOUND;
534 hobjdest = WinQueryObject(dir);
535 if(hobjdest) {
536 ret = ERROR_GEN_FAILURE;
537 hobjsrc = WinCopyObject(hobjsrc,
538 hobjdest,
539 0);
540 if(hobjsrc)
541 ret = 0;
542 }
543 }
544 }
545 return ret;
546
547 case MOVE:
548 *dir = 0;
549 if(olddisk == newdisk) { /* same drive */
550 /* make temporary copy in case move fails */
551 if(IsFile(fullnewname) != -1 &&
552 stricmp(oldname,
553 fullnewname)) {
554 strcpy(dir,
555 fullnewname);
556 p = strrchr(dir,'\\');
557 if(p)
558 *p = 0;
559 strcat(dir,"\\");
560 MakeTempName(dir);
561 if(DosMove(fullnewname,
562 dir))
563 *dir = 0;
564 }
565 DosError(FERR_DISABLEHARDERR);
566 ret = DosMove(oldname,
567 fullnewname); /* move it */
568 if(ret &&
569 *dir) { /* failed -- clean up */
570 DosError(FERR_DISABLEHARDERR);
571 if(!DosMove(dir,
572 fullnewname))
573 Broadcast((HAB)0,
574 hwndMain,
575 UM_UPDATERECORD,
576 MPFROMP(dir),
577 MPVOID);
578 }
579 else if(!ret &&
580 *dir) {
581 if(!IsFile(dir)) {
582 if(!strchr(dir,'?') &&
583 !strchr(dir,'*'))
584 wipeallf("%s\\*",dir);
585 DosError(FERR_DISABLEHARDERR);
586 if(DosDeleteDir(dir)) {
587 make_deleteable(dir);
588 DosDeleteDir(dir);
589 }
590 }
591 else if(IsFile(dir) > 0) {
592 DosError(FERR_DISABLEHARDERR);
593 if(DosForceDelete(dir)) {
594 make_deleteable(dir);
595 DosForceDelete(dir);
596 }
597 if(zaplong)
598 ZapLongName(dir);
599 Broadcast((HAB)0,
600 hwndMain,
601 UM_UPDATERECORD,
602 MPFROMP(dir),
603 MPVOID);
604 }
605 }
606 }
607 else { /* different drives */
608 DosError(FERR_DISABLEHARDERR);
609 ret = DosCopy(oldname,
610 fullnewname,
611 DCPY_EXISTING); /* <=-NOTE! */
612 if(ret == ERROR_DISK_CHANGE) {
613 DosError(FERR_ENABLEHARDERR);
614 ret = DosCopy(oldname,
615 fullnewname,
616 DCPY_EXISTING);
617 diskchange = TRUE;
618 }
619 if(ret == ERROR_INVALID_NAME ||
620 ret == ERROR_FILENAME_EXCED_RANGE) {
621 if(TruncName(fullnewname,
622 shortname)) { /* make 8.3 filename */
623 DosError(FERR_DISABLEHARDERR);
624 ret = DosCopy(oldname,
625 shortname,
626 DCPY_EXISTING);
627 if(!ret) { /* success -- write longname ea */
628 WriteLongName(shortname,
629 fullnewname);
630 strcpy(fullnewname,
631 shortname);
632 /* broadcast fixup msg to windows */
633 Broadcast((HAB)0,
634 hwndMain,
635 UM_UPDATERECORD,
636 MPFROMP(shortname),
637 MPVOID);
638 }
639 }
640 }
641 else if(!ret &&
642 *longname) {
643
644 CHAR fixname[CCHMAXPATH];
645
646 strcpy(fixname,
647 fullnewname);
648 p = strrchr(fixname,'\\');
649 if(p) {
650 p++;
651 *p = 0;
652 }
653 strcat(fixname,
654 longname);
655 DosError(FERR_DISABLEHARDERR);
656 DosMove(fullnewname,
657 fixname);
658 strcpy(fullnewname,
659 fixname);
660 if(zaplong)
661 ZapLongName(fixname);
662 Broadcast((HAB)0,
663 hwndMain,
664 UM_UPDATERECORD,
665 MPFROMP(fixname),
666 MPVOID);
667 }
668 if(!ret) { /* double-check success */
669 DosError(FERR_DISABLEHARDERR);
670 rc = DosQueryPathInfo(fullnewname,
671 FIL_STANDARD,
672 &st2,
673 sizeof(FILESTATUS3));
674 if(rc == ERROR_DISK_CHANGE) {
675 DosError(FERR_ENABLEHARDERR);
676 rc = DosQueryPathInfo(fullnewname,
677 FIL_STANDARD,
678 &st2,
679 sizeof(FILESTATUS3));
680 }
681 if(!rc && st2.cbFile == st.cbFile) { /* seems to have worked... */
682 DosError(FERR_DISABLEHARDERR);
683 if(diskchange) {
684 DosError(FERR_ENABLEHARDERR);
685 DosQueryPathInfo(oldname,
686 FIL_STANDARD,
687 &dummy,
688 sizeof(FILESTATUS3)); /* force disk change */
689 }
690 if(!(st2.attrFile & FILE_DIRECTORY)) /* erase file */
691 unlinkf("%s",oldname);
692 else { /* remove directory */
693 wipeallf("%s\\*",oldname);
694 DosError(FERR_DISABLEHARDERR);
695 if(DosDeleteDir(oldname)) {
696 make_deleteable(oldname);
697 DosDeleteDir(oldname);
698 }
699 }
700 }
701 }
702 }
703 return ret;
704
705 case COPY:
706 DosError(FERR_DISABLEHARDERR);
707 ret = DosCopy(oldname,
708 fullnewname,
709 DCPY_EXISTING); /* <=-NOTE! */
710 if(ret == ERROR_DISK_CHANGE) {
711 DosError(FERR_ENABLEHARDERR);
712 ret = DosCopy(oldname,
713 fullnewname,
714 DCPY_EXISTING);
715 diskchange = TRUE;
716 }
717 if(ret == ERROR_INVALID_NAME ||
718 ret == ERROR_FILENAME_EXCED_RANGE) {
719 if(TruncName(fullnewname,
720 shortname)) {
721 DosError((diskchange) ?
722 FERR_ENABLEHARDERR :
723 FERR_DISABLEHARDERR);
724 ret = DosCopy(oldname,
725 shortname,
726 DCPY_EXISTING);
727 if(!ret) {
728 WriteLongName(shortname,
729 fullnewname);
730 strcpy(fullnewname,
731 shortname);
732 Broadcast((HAB)0,
733 hwndMain,
734 UM_UPDATERECORD,
735 MPFROMP(shortname),
736 MPVOID);
737 }
738 }
739 }
740 else if(!ret &&
741 *longname) {
742
743 CHAR fixname[CCHMAXPATH];
744
745 strcpy(fixname,
746 fullnewname);
747 p = strrchr(fixname,'\\');
748 if(p) {
749 p++;
750 *p = 0;
751 }
752 strcat(fixname,
753 longname);
754 DosError(FERR_DISABLEHARDERR);
755 DosMove(fullnewname,
756 fixname);
757 if(zaplong)
758 ZapLongName(fixname);
759 Broadcast((HAB)0,
760 hwndMain,
761 UM_UPDATERECORD,
762 MPFROMP(fixname),
763 MPVOID);
764 }
765 return ret;
766
767 default: /* shouldn't happen */
768 DosBeep(50,100);
769 break;
770 }
771 return (APIRET)-3; /* bad type */
772}
773
774
775INT make_deleteable (CHAR *filename) {
776
777 INT ret = -1;
778 FILESTATUS3 fsi;
779
780 DosError(FERR_DISABLEHARDERR);
781 if(!DosQueryPathInfo(filename,
782 FIL_STANDARD,
783 &fsi,
784 sizeof(FILESTATUS3))) {
785 fsi.attrFile = 0;
786 DosError(FERR_DISABLEHARDERR);
787 if(!DosSetPathInfo(filename,
788 FIL_STANDARD,
789 &fsi,
790 sizeof(FILESTATUS3),
791 0L))
792 ret = 0;
793 }
794 return ret;
795}
796
797
798INT wipeallf (CHAR *string,...) {
799
800 /* unlink everything from directory on down... */
801
802 FILEFINDBUF3 *f;
803 HDIR search_handle;
804 ULONG num_matches;
805 CHAR *p,*ss,*str;
806 CHAR s[CCHMAXPATH],mask[257];
807 va_list ap;
808 INT rc;
809
810 va_start(ap,string);
811 vsprintf(s,string,ap);
812 va_end(ap);
813
814 if(!*s)
815 return -1;
816 p = s;
817 while((p = strchr(p,'/')) != NULL) {
818 *p = '\\';
819 p++;
820 }
821
822 str = strdup(s);
823 if(!str)
824 return -1;
825
826 { /* safety net -- disallow deleting a root dir or partial name */
827 CHAR temp;
828
829 p = strrchr(str,'\\');
830 if(p) {
831 p++;
832 temp = *p;
833 *p = 0;
834 if(IsRoot(str) || !IsFullName(str)) { /* under no circumstances! */
835 free(str);
836 DosBeep(100,250);
837 return -1;
838 }
839 *p = temp;
840 }
841 }
842
843 p = s;
844 p = strrchr(s,'\\'); /* strip s to just path */
845 if(!p)
846 p = strrchr(s,':');
847 if(p) {
848 p++;
849 strncpy(mask,p,256);
850 mask[256] = 0;
851 *p = 0;
852 }
853 else {
854 *mask = 0;
855 *s = 0;
856 }
857
858 ss = (CHAR *)malloc(CCHMAXPATH);
859 f = (FILEFINDBUF3 *)malloc(sizeof(FILEFINDBUF3));
860 if(!ss || !f) {
861 if(ss)
862 free(ss);
863 if(f)
864 free(f);
865 free(str);
866 return -1;
867 }
868
869 search_handle = HDIR_CREATE;
870 num_matches = 1L;
871
872 DosError(FERR_DISABLEHARDERR);
873 if(!DosFindFirst(str,&search_handle,FILE_NORMAL | FILE_DIRECTORY |
874 FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,f,
875 sizeof(FILEFINDBUF3),&num_matches,FIL_STANDARD)) {
876
877 strcpy(ss,s);
878 p = &ss[strlen(ss)];
879
880 do {
881 strcpy(p,f->achName);
882 if(f->attrFile & FILE_DIRECTORY) {
883 if(strcmp(f->achName,".") && strcmp(f->achName,"..")) {
884 wipeallf("%s/%s",ss,mask); /* recurse to wipe files */
885 DosError(FERR_DISABLEHARDERR);
886 if(DosDeleteDir(ss)) { /* remove directory */
887 make_deleteable(ss);
888 DosError(FERR_DISABLEHARDERR);
889 DosDeleteDir(ss);
890 }
891 }
892 }
893 else {
894 DosError(FERR_DISABLEHARDERR);
895 if(DosForceDelete(ss)) {
896 make_deleteable(ss);
897 DosError(FERR_DISABLEHARDERR);
898 rc = (INT)DosForceDelete(ss);
899 if(rc)
900 return rc;
901 }
902 }
903 num_matches = 1L;
904 DosError(FERR_DISABLEHARDERR);
905 } while(!DosFindNext(search_handle,f,sizeof(FILEFINDBUF3),
906 &num_matches));
907 DosFindClose(search_handle);
908 }
909
910 free(f);
911 free(ss);
912 free(str);
913 return 0;
914}
915
916
917INT unlink_allf (CHAR *string,...) {
918
919 /* wildcard delete */
920
921 FILEFINDBUF3 *f;
922 HDIR search_handle;
923 ULONG num_matches;
924 CHAR *p,*ss,*str;
925 CHAR s[CCHMAXPATH];
926 va_list ap;
927
928 va_start(ap,string);
929 vsprintf(s,string,ap);
930 va_end(ap);
931
932 if(!*s)
933 return -1;
934 p = s;
935 while((p = strchr(p,'/')) != NULL) {
936 *p = '\\';
937 p++;
938 }
939
940 str = strdup(s);
941 if(!str)
942 return -1;
943
944 p = s;
945 p = strrchr(s,'\\'); /* strip s to just path */
946 if(!p)
947 p = strrchr(s,':');
948 if(p) {
949 p++;
950 *p = 0;
951 }
952 else
953 *s = 0;
954
955 ss = (CHAR *)malloc(CCHMAXPATH);
956 f = (FILEFINDBUF3 *)malloc(sizeof(FILEFINDBUF3));
957 if(!ss || !f) {
958 if(ss)
959 free(ss);
960 if(f)
961 free(f);
962 free(str);
963 return -1;
964 }
965
966 search_handle = HDIR_CREATE;
967 num_matches = 1L;
968
969 DosError(FERR_DISABLEHARDERR);
970 if(!DosFindFirst(str,&search_handle,FILE_NORMAL,f,
971 sizeof(FILEFINDBUF3),&num_matches,FIL_STANDARD)) {
972
973 strcpy(ss,s);
974 p = &ss[strlen(ss)];
975
976 do {
977 strcpy(p,f->achName);
978 unlinkf("%s",ss);
979 num_matches = 1L;
980 DosError(FERR_DISABLEHARDERR);
981 } while(!DosFindNext(search_handle,f,sizeof(FILEFINDBUF3),
982 &num_matches));
983 DosFindClose(search_handle);
984 }
985
986 free(f);
987 free(ss);
988 free(str);
989 return 0;
990}
991
992
993INT unlinkf (CHAR *string,...) {
994
995 CHAR buffer[CCHMAXPATH];
996 va_list ap;
997
998 va_start(ap,string);
999 vsprintf(buffer,string,ap);
1000 va_end(ap);
1001
1002 if(!strstr(buffer,ArcTempRoot)) {
1003 DosError(FERR_DISABLEHARDERR);
1004 if(DosDelete(buffer)) {
1005 make_deleteable(buffer);
1006 DosError(FERR_DISABLEHARDERR);
1007 return DosDelete(buffer);
1008 }
1009 }
1010 else {
1011 DosError(FERR_DISABLEHARDERR);
1012 if(DosForceDelete(buffer)) {
1013 make_deleteable(buffer);
1014 DosError(FERR_DISABLEHARDERR);
1015 return DosForceDelete(buffer);
1016 }
1017 }
1018 return 0;
1019}
1020
Note: See TracBrowser for help on using the repository browser.