?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated PCI IDs to latest snapshot.
[tangerine.git] / workbench / system / Wanderer / filesystems.c
blob600b87bb06abf3d71bd3c1dc9449b2d62a9391e6
1 /*
2 Copyright © 2007-2009, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include "filesystems.h"
7
8 struct TagItem DummyTags[] = { {TAG_DONE, 0}};
9
10 /* define some nonglobal data that can be used by the display hook */
11
12 ///strcrem()
13 void strcrem(char *s, char *d, char c)
14 {
15 while (*s) {
16 if (*s != c) *d++= *s;
17 s++;
18 }
19 *d = 0;
20 }
21 ///
22
23 ///AskChoiceNew()
24 WORD AskChoiceNew(char *title, char *strg, char *gadgets, UWORD sel, BOOL centered)
25 {
26
27 Object *app, *win;
28 Object *button, *bObject, *selObject;
29 LONG back, old;
30 BOOL running = TRUE;
31 ULONG signals;
32 ULONG id;
33 char Buffer[64], Buffer1[64];
34
35 back = 0;
36
37 app = MUI_NewObject(MUIC_Application,
38
39 MUIA_Application_Title, (IPTR)"Requester",
40 MUIA_Application_Base, (IPTR)"WANDERER_REQ",
41
42 SubWindow, (IPTR)(win = MUI_NewObject(MUIC_Window,
43 MUIA_Window_Title, title,
44 MUIA_Window_Activate, TRUE,
45 MUIA_Window_DepthGadget, TRUE,
46 MUIA_Window_SizeGadget, FALSE,
47 MUIA_Window_AppWindow, FALSE,
48 MUIA_Window_CloseGadget, FALSE,
49 MUIA_Window_Borderless, FALSE,
50 MUIA_Window_TopEdge, MUIV_Window_TopEdge_Moused,
51 MUIA_Window_LeftEdge, MUIV_Window_LeftEdge_Moused,
52
53 WindowContents, (IPTR)MUI_NewObject(MUIC_Group,
54 Child, (IPTR)MUI_NewObject(MUIC_Text,
55 TextFrame,
56 MUIA_InnerLeft,(12),
57 MUIA_InnerRight,(12),
58 MUIA_InnerTop,(12),
59 MUIA_InnerBottom,(12),
60 MUIA_Background, MUII_TextBack,
61 MUIA_Text_PreParse, (IPTR)"\33c",
62 MUIA_Text_Contents, (IPTR)strg,
63 TAG_DONE),
64 Child, (IPTR)(bObject = MUI_NewObject(MUIC_Group,MUIA_Group_Horiz, TRUE,TAG_DONE)),
65 TAG_DONE),
66 TAG_DONE)),
67 TAG_DONE);
68
69
70 if (app)
71 {
72 old = 0;
73 back = 11;
74 selObject = NULL;
75
76 while (old != -1)
77 {
78 old = SplitName(gadgets, '|', Buffer, old, sizeof(Buffer));
79 if (old == -1) back = 10;
80 strcrem(Buffer, Buffer1, '_');
81 button = SimpleButton(Buffer1);
82 if (button)
83 {
84 if ((back-10) == sel) selObject = button;
85 set(button, MUIA_CycleChain, 1);
86 DoMethod(bObject, MUIM_Group_InitChange);
87 DoMethod(bObject, OM_ADDMEMBER, button);
88 DoMethod(bObject, MUIM_Group_ExitChange);
89 DoMethod(button,MUIM_Notify,MUIA_Pressed, FALSE, app,2,MUIM_Application_ReturnID,back);
90 }
91 back++;
92 }
93
94 back = -1;
95
96 if (centered)
97 {
98 set (win, MUIA_Window_TopEdge, MUIV_Window_TopEdge_Centered);
99 set (win, MUIA_Window_LeftEdge, MUIV_Window_LeftEdge_Centered);
100 }
101 if (selObject) set(win, MUIA_Window_ActiveObject, selObject);
102 set(win,MUIA_Window_Open,TRUE);
103
104 while (running)
105 {
106 id = DoMethod(app,MUIM_Application_Input,&signals);
107 switch (id)
108 {
109
110 case MUIV_Application_ReturnID_Quit:
111 running = FALSE;
112 break;
113 case 10:
114 running = FALSE;
115 back = 0;
116 break;
117 case 11:
118 running = FALSE;
119 back = 1;
120 break;
121 case 12:
122 running = FALSE;
123 back = 2;
124 break;
125 case 13:
126 running = FALSE;
127 back = 3;
128 break;
129 case 14:
130 running = FALSE;
131 back = 4;
132 break;
133 case 15:
134 running = FALSE;
135 back = 5;
136 break;
137 case 16:
138 running = FALSE;
139 back = 6;
140 break;
141 case 17:
142 running = FALSE;
143 back = 7;
144 break;
145 case 18:
146 running = FALSE;
147 back = 8;
148 break;
149 }
150 if (running && signals) Wait(signals);
151 }
152 set(win,MUIA_Window_Open,FALSE);
153 MUI_DisposeObject(app);
154 }
155 return back;
156 }
157 ///
158
159 /// AskChoice()
160 WORD AskChoice(char *title, char *strg, char *gadgets, UWORD sel)
161 {
162 return AskChoiceNew(title, strg, gadgets, sel, FALSE);
163 }
164 ///
165
166 ///AskChoiceCentered()
167 WORD AskChoiceCentered(char *title, char *strg, char *gadgets, UWORD sel)
168 {
169 return AskChoiceNew(title, strg, gadgets, sel, TRUE);
170 }
171 ///
172
173 ///combinePath()
174 char *combinePath(APTR pool, char *path, char *file)
175 {
176 int l;
177 char *out;
178 if ((path == NULL) || (file == NULL)) return NULL;
179 if (strlen(path) == 0) return NULL;
180 if (strlen(file) == 0) return NULL;
181
182 l = strlen(path) + strlen(file) + 1;
183 if (path[strlen(path)-1] != '/') l++;
184
185 if (pool == NULL) out = AllocVec(l, MEMF_CLEAR);
186 else out = AllocPooled(pool, l);
187
188 if (out)
189 {
190 strcpy(out, path);
191 AddPart(out, file, l);
192 }
193 return out;
194 }
195 ///
196
197 ///allocPath()
198 char *allocPath(APTR pool, char *str)
199 {
200 char *s0, *s1, *s;
201 int l;
202
203 s = NULL;
204 s0 = str;
205
206 s1 = PathPart(str);
207 if (s1)
208 {
209 for (l=0; s0 != s1; s0++,l++);
210
211 s = AllocPooled(pool, l+1);
212 if (s) strncpy(s, str, l);
213 }
214 return s;
215 }
216 ///
217
218 ///freeString()
219 void freeString(APTR pool, char *str)
220 {
221 if (str)
222 {
223 if (pool == NULL)
224 FreeVec(str);
225 else
226 FreePooled(pool, str, strlen(str)+1);
227 }
228 }
229 ///
230
231 ///allocString()
232 /*
233 ** allocates memory for a string and copies them to the new buffer
234 **
235 ** inputs: str source string
236 ** return: char pointer to string or NULL
237 **
238 */
239 char *allocString(APTR pool, char *str)
240 {
241 char *b;
242 int l;
243
244 if (str == NULL) return NULL;
245
246 l = strlen(str);
247
248 if (pool == NULL)
249 b = (char*) AllocVec(l+1, MEMF_CLEAR);
250 else b = (char*) AllocPooled(pool, l+1);
251
252 if (b && (l>0)) strncpy (b, str, l);
253 return b;
254 }
255 ///
256
257 ///InfoRename()
258 void InfoRename(APTR pool, char *from, char *to)
259 {
260 char *frominfo, *toinfo;
261
262 if ((from == NULL) || (to == NULL)) return;
263
264 frominfo = AllocPooled(pool, strlen(from)+6);
265
266 if (frominfo)
267 {
268 strncpy (frominfo, from, strlen(from));
269 strcat(frominfo,".info");
270 toinfo = AllocPooled(pool, strlen(to)+6);
271
272 if (toinfo)
273 {
274 strncpy (toinfo, to, strlen(to));
275 strcat(toinfo,".info");
276 if (Rename(from, to)) Rename(frominfo, toinfo);
277 freeString(pool, toinfo);
278 }
279 freeString(pool, frominfo);
280 }
281 }
282 ///
283
284 ///allocPathFromLock()
285 char *allocPathFromLock(APTR pool, BPTR lock)
286 {
287 char *pathb, *path;
288
289 path = NULL;
290 pathb = AllocPooled(pool, PATHBUFFERSIZE);
291 if (pathb)
292 {
293 if (NameFromLock(lock, pathb, PATHBUFFERSIZE))
294 {
295 path = allocString(pool, pathb);
296 }
297 FreePooled(pool, pathb, PATHBUFFERSIZE);
298 }
299 return path;
300 }
301 ///
302
303 ///combineString()
304 char *CombineString(char *format, ...) {
305
306 int cnt = 0, cnt1;
307 int len;
308 char *s, *s1, *str, *p;
309 char *back = NULL;
310
311 va_list ap;
312 s = format;
313 while ((s = strstr(s,"%s")) != NULL) {cnt++; s++; }
314
315 if (cnt >0)
316 {
317 len = strlen(format) - 2*cnt;
318 va_start(ap, format);
319 cnt1 = cnt;
320
321 while (cnt1--)
322 {
323 p = va_arg(ap, char *);
324 len += strlen(p);
325 };
326 va_end(ap);
327 len++;
328 if (len>0)
329 {
330 back = AllocVec(len, MEMF_CLEAR);
331 if (back)
332 {
333 str = back;
334 s = format;
335 va_start(ap, format);
336 while ((s1 = strstr(s, "%s")) != NULL)
337 {
338 p = va_arg(ap, char *);
339 len = s1-s;
340 strncpy(str, s, len);
341 s = s1+2;
342 str += len;
343 strncpy(str, p, strlen(p));
344 str += strlen(p);
345 };
346 if (s) strncpy(str, s, strlen(s));
347 va_end(ap);
348 }
349 }
350 }
351 return back;
352 }
353 ///
354
355 ///isPathRecursive()
356 ULONG isPathRecursive(APTR pool, char *source, char *destination)
357 {
358 BPTR srcLock, destLock;
359 ULONG back;
360 char *p1, *p2;
361
362 back = PATH_NOINFO;
363 srcLock = Lock(source, SHARED_LOCK);
364 if (srcLock)
365 {
366 destLock = Lock(destination, SHARED_LOCK);
367 if (destLock)
368 {
369 p1 = allocPathFromLock(pool, srcLock);
370 if (p1)
371 {
372 p2 = allocPathFromLock(pool, destLock);
373 if (p2)
374 {
375 if (strstr(p2, p1) == p2) back = PATH_RECURSIVE; else back = PATH_NONRECURSIVE;
376
377 freeString(pool, p2);
378 }
379 freeString(pool, p1);
380 }
381 UnLock(destLock);
382 }
383 UnLock(srcLock);
384 }
385 return back;
386 }
387 ///
388
389 ///FileExists()
390 BOOL FileExists(char *name)
391 {
392 BOOL info;
393 BPTR nLock;
394 APTR win;
395 struct Task *t;
396
397 t = FindTask(NULL);
398 win = ((struct Process *) t)->pr_WindowPtr;
399 ((struct Process *) t)->pr_WindowPtr = (APTR) -1; //disable error requester
400
401 info = FALSE;
402 nLock = Lock(name, SHARED_LOCK);
403 if (nLock)
404 {
405 UnLock(nLock);
406 info = TRUE;
407 }
408 ((struct Process *) t)->pr_WindowPtr = win; //enable error requester
409 return info;
410 }
411 ///
412
413 ///GetFileLength()
414 LONG GetFileLength(char *name)
415 {
416 LONG info = -1;
417 BPTR in;
418 APTR win;
419 struct Task *t;
420
421 t = FindTask(NULL);
422 win = ((struct Process *) t)->pr_WindowPtr;
423 ((struct Process *) t)->pr_WindowPtr = (APTR) -1; //disable error requester
424
425 in = Open(name, MODE_OLDFILE);
426 if (in) {
427 Seek(in, 0, OFFSET_END);
428 info = Seek(in, 0, OFFSET_BEGINNING);
429 Close(in);
430 }
431 ((struct Process *) t)->pr_WindowPtr = win; //enable error requester
432 return info;
433 }
434 ///
435
436 ///DisposeFileInformations()
437 void DisposeFileInformations(APTR pool, struct FileInfo *fi)
438 {
439 if (fi->comment) freeString(pool, fi->comment);
440 fi->comment = NULL;
441 }
442 ///
443
444 ///GetFileInformations()
445 BOOL GetFileInformations(APTR pool, char *name, struct FileInfo *fi)
446 {
447 struct FileInfoBlock *FIB;
448 LONG Success2;
449 BOOL info = FALSE;
450 BPTR nLock;
451
452 fi->len = 0;
453 fi->comment = NULL;
454 fi->protection = 0;
455
456 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
457 if (FIB)
458 {
459 nLock = Lock(name, ACCESS_READ);
460 if (nLock)
461 {
462 Success2 = Examine(nLock,FIB);
463 if (Success2)
464 {
465 info = TRUE;
466 fi->len = FIB->fib_Size;
467 if (strlen(FIB->fib_Comment) > 0) fi->comment = allocString(pool, FIB->fib_Comment);
468 fi->protection = FIB->fib_Protection;
469 }
470 UnLock(nLock);
471 }
472 FreeDosObject (DOS_FIB,(APTR) FIB);
473 }
474 return info;
475 }
476 ///
477
478 ///GetFileInfo()
479 LONG GetFileInfo(char *name)
480 {
481 struct FileInfoBlock *FIB;
482 LONG info,Success2;
483 BPTR nLock;
484
485 info = -1;
486
487 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
488 if (FIB)
489 {
490 nLock = Lock(name, ACCESS_READ);
491 if (nLock)
492 {
493 Success2 = Examine(nLock,FIB);
494 if (Success2)
495 {
496 info = 0;
497 if (FIB->fib_DirEntryType>0) info |= FILEINFO_DIR;
498 if ((FIB->fib_Protection & FIBF_DELETE) != 0) info |= FILEINFO_PROTECTED;
499 if ((FIB->fib_Protection & FIBF_WRITE) != 0) info |= FILEINFO_WRITE;
500 }
501 UnLock(nLock);
502 }
503 FreeDosObject (DOS_FIB,(APTR) FIB);
504 }
505 return info;
506 }
507 ///
508
509 ///GetProtectionInfo()
510 LONG GetProtectionInfo(char *name)
511 {
512 struct FileInfoBlock *FIB;
513 LONG info,Success2;
514 BPTR nLock;
515
516 info = 0;
517
518 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
519 if (FIB)
520 {
521 nLock = Lock(name, ACCESS_READ);
522 if (nLock)
523 {
524 Success2 = Examine(nLock,FIB);
525 if (Success2)
526 {
527 info = FIB->fib_Protection;
528 }
529 UnLock(nLock);
530 }
531 FreeDosObject (DOS_FIB,(APTR) FIB);
532 }
533 return info;
534 }
535 ///
536
537 ///GetCommentInfo()
538 char *GetCommentInfo(APTR pool, char *name)
539 {
540 struct FileInfoBlock *FIB;
541 LONG Success2;
542 BPTR nLock;
543 char *info;
544
545 info = NULL;
546
547 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
548 if (FIB)
549 {
550 nLock = Lock(name, ACCESS_READ);
551 if (nLock)
552 {
553 Success2 = Examine(nLock,FIB);
554 if (Success2)
555 {
556 info = allocString(pool, (char*) &FIB->fib_Comment);
557 }
558 UnLock(nLock);
559 }
560 FreeDosObject (DOS_FIB,(APTR) FIB);
561 }
562 return info;
563 }
564 ///
565
566 ///deleteFile()
567 BOOL deleteFile(char *file) {
568 DeleteFile(file);
569 return TRUE;
570 }
571 ///
572
573 ///copyFile()
574 BOOL copyFile(APTR pool, char *file, char *destpath, struct FileInfoBlock *fileinfo, struct Hook *displayHook, struct dCopyStruct *display) {
575 struct FileInfoBlock *fib;
576 char *to;
577 LONG clen, wlen;
578 LONG bufferlen = COPYLEN;
579 LONG filelen = 0;
580 BOOL quit = TRUE;
581 BPTR in, out;
582 BYTE *buffer;
583 BPTR nLock;
584
585 if (display != NULL) display->totallen = 0;
586 if (display != NULL) display->actlen = 0;
587 if (fileinfo)
588 {
589 filelen = fileinfo->fib_Size;
590 if (fileinfo->fib_Size <= COPYLEN) bufferlen = fileinfo->fib_Size;
591 if (bufferlen < 8192) bufferlen = 8192;
592 fib = fileinfo;
593 }
594 else
595 {
596 fib = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
597 if (fib)
598 {
599 nLock = Lock(file, ACCESS_READ);
600 if (nLock)
601 {
602 if (Examine(nLock,fib) == 0)
603 {
604 UnLock(nLock);
605 return TRUE;
606 }
607 UnLock(nLock);
608 filelen = fib->fib_Size;
609 if (fib->fib_Size <= COPYLEN) bufferlen = fib->fib_Size;
610 if (bufferlen < 8192) bufferlen = 8192;
611 }
612 }
613 else
614 {
615 return TRUE;
616 }
617 }
618 to = combinePath(pool, destpath, FilePart(file));
619 if (to)
620 {
621 buffer = AllocPooled(pool, bufferlen);
622 if (buffer)
623 {
624 in = Open(file, MODE_OLDFILE);
625 if (in)
626 {
627 out = Open(to, MODE_NEWFILE);
628 if (out)
629 {
630 BOOL stop = FALSE;
631 unsigned int difftime = clock();
632 do
633 {
634 clen = Read(in, buffer, bufferlen);
635 if ((clen !=0) && (clen != -1))
636 {
637 wlen = Write(out, buffer,clen);
638 if (display)
639 {
640 display->difftime = clock() - difftime;
641 if (display->difftime < 1) display->difftime = 1;
642 display->actlen = clen;
643 display->totallen += clen;
644 display->filelen = filelen;
645 if (displayHook)
646 {
647 display->flags |= ACTION_UPDATE;
648 stop = CallHook(displayHook, (Object *) display, NULL);
649 }
650 }
651
652 if (clen != wlen) clen = 0;
653 }
654 }
655 while ((clen !=0) && (clen != -1) && !stop);
656
657 quit = stop;
658
659 Close(out);
660
661 if (fib)
662 {
663 SetComment(to, fib->fib_Comment);
664 SetProtection(to, fib->fib_Protection);
665 if (fileinfo == NULL) FreeDosObject (DOS_FIB,(APTR) fib);
666 }
667 }
668 Close(in);
669 }
670 FreePooled(pool, buffer, bufferlen);
671 }
672 freeString(pool, to);
673 }
674 return quit;
675 }
676 ///
677
678 ///actionDir()
679 BOOL actionDir(APTR pool, ULONG flags, char *source, char *dest, BOOL quit, UWORD delmode, UWORD protectmode, UWORD overwritemode, struct Hook *dHook, struct Hook *delHook, APTR userdata)
680 {
681 struct FileInfoBlock *FIB, *FIB2;
682 struct dCopyStruct display;
683 struct dCopyStruct delDisplay;
684 struct FileEntry *fe, *fef, *fel;
685
686 BPTR NewLock, cDir, nDir, nLock;
687 WORD dmode, pmode, omode, dm, pm, om;
688 ULONG Success, Success1, Success2, DosError, len;
689 char *dname, *comment, *dpath;
690 BOOL del, created, unprotect, failure;
691 BOOL stop, overwrite;
692 LONG info, prot;
693
694 if (quit) return TRUE;
695
696 display.userdata = userdata;
697 delDisplay.userdata = userdata;
698
699 dmode = delmode;
700 omode = overwritemode;
701 pmode = protectmode;
702
703 fef = NULL;
704 fel = NULL;
705
706 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
707 if (FIB)
708 {
709 FIB2 = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
710 if (FIB2)
711 {
712 NewLock = Lock(source ,ACCESS_READ);
713 if (NewLock)
714 {
715 cDir = CurrentDir(NewLock);
716
717 Success1=Examine(NewLock,FIB);
718 if (Success1)
719 {
720 stop = quit;
721 do
722 {
723 Success=ExNext(NewLock,FIB);
724
725 if ((flags & (ACTION_DELETE | ACTION_COPY)) == ACTION_DELETE)
726 {
727 if (dmode == DELMODE_NONE) Success = FALSE;
728 }
729
730 if (Success && Success1)
731 {
732 if (FIB->fib_DirEntryType>0)
733 {
734
735 dname = NULL;
736
737 if (((flags & ACTION_COPY) != 0) && dest)
738 {
739 dname = combinePath(pool, dest, FIB->fib_FileName);
740 if (dname)
741 {
742 created = FALSE;
743 nLock = Lock(dname, ACCESS_READ);
744 if (nLock)
745 {
746 Success2 = Examine(nLock,FIB2);
747 if (Success2) if (FIB2->fib_DirEntryType>0) created = TRUE;
748 UnLock(nLock);
749 }
750 if (!created)
751 {
752 nDir = CreateDir(dname);
753 if (nDir)
754 {
755 prot = GetProtectionInfo(FIB->fib_FileName);
756 comment = GetCommentInfo(pool, FIB->fib_FileName);
757 if (comment) SetComment(dname, comment);
758 SetProtection(dname, prot);
759 freeString(pool, comment);
760
761 created = TRUE;
762 UnLock(nDir);
763 }
764 }
765 }
766 }
767 unprotect = FALSE;
768 del = FALSE;
769
770 if (delHook && (dmode != DELMODE_NONE) && ((flags & ACTION_DELETE) != 0))
771 {
772 if ((dmode == DELMODE_ASK) || (dmode == DELMODE_DELETE) || (dmode == DELMODE_ALL) || (dmode == DELMODE_NO))
773 {
774 delDisplay.spath = FIB->fib_FileName;
775 delDisplay.file = NULL;
776 delDisplay.type = 0;
777 delDisplay.filelen = FIB->fib_Size;
778 if (dmode != DELMODE_ALL) dmode = CallHook(delHook, (Object *) &delDisplay, NULL);
779 if ((dmode == DELMODE_ALL) || (dmode == DELMODE_DELETE))
780 {
781
782 unprotect = FALSE;
783 info = GetFileInfo(FIB->fib_FileName);
784 if ((info & (FILEINFO_PROTECTED|FILEINFO_WRITE)) != 0)
785 {
786 if (pmode != DELMODE_NONE)
787 {
788 if (
789 (pmode == DELMODE_ASK) || (pmode == DELMODE_DELETE) ||
790 (pmode == DELMODE_ALL) || (pmode == DELMODE_NO)
791 )
792 {
793 delDisplay.spath = FIB->fib_FileName;
794 delDisplay.file = NULL;
795 delDisplay.type = 1;
796 delDisplay.filelen = 0;
797 if (pmode != DELMODE_ALL) pmode = CallHook(delHook, (Object *) &delDisplay, NULL);
798 if ((pmode == DELMODE_ALL) || (pmode == DELMODE_DELETE))
799 {
800 SetProtection(FIB->fib_FileName, 0);
801 unprotect = TRUE;
802 }
803 }
804 }
805 }
806 else unprotect = TRUE;
807
808 if (unprotect)
809 {
810 del = TRUE;
811 }
812 }
813 }
814 }
815
816 dm = dmode;
817 om = omode;
818 pm = pmode;
819
820 if (om == DELMODE_NO) om = DELMODE_NONE;
821 if (om == DELMODE_DELETE) om = DELMODE_ALL;
822
823 if (pm == DELMODE_NO) pm = DELMODE_NONE;
824 if (pm == DELMODE_DELETE) pm = DELMODE_ALL;
825
826 if (dm == DELMODE_NO) dm = DELMODE_NONE;
827 if (dm == DELMODE_DELETE) dm = DELMODE_ALL;
828
829 if (created || ((flags & ACTION_DELETE) !=0))
830 {
831 if (((dmode == DELMODE_NO) || (dmode == DELMODE_NONE)) && (flags == ACTION_DELETE))
832 {
833 quit = FALSE;
834 }
835 else
836 {
837 quit = actionDir(pool, flags, FIB->fib_FileName, dname, quit, dm, pm, om, dHook, delHook, userdata);
838 }
839 }
840
841 if (!quit && del && unprotect)
842 {
843 if (FIB->fib_FileName)
844 {
845 len = strlen(FIB->fib_FileName);
846 if (len>0)
847 {
848
849 fe = AllocPooled(pool, sizeof(struct FileEntry) + len);
850 if (fe)
851 {
852 strcpy(fe->name, FIB->fib_FileName);
853 if (fel)
854 {
855 fel->next = fe;
856 fel = fe;
857 }
858 else
859 {
860 fef = fe;
861 fel = fe;
862 }
863 }
864 }
865 }
866 }
867 if (dname) freeString(pool, dname);
868 }
869 else
870 {
871 if (dHook)
872 {
873 display.file = FIB->fib_FileName;
874 display.filelen = FIB->fib_Size;
875 display.spath = source;
876 display.dpath = dest;
877 display.flags = (flags &= ~ACTION_UPDATE);
878 display.totallen = 0;
879 display.actlen = 0;
880
881 quit = CallHook(dHook, (Object *) &display, NULL);
882 }
883
884 overwrite = TRUE;
885
886 if (((flags & ACTION_COPY) != 0) && dest)
887 {
888 dpath = combinePath(pool, dest, FIB->fib_FileName);
889 if (dpath)
890 {
891 info = GetFileInfo(dpath);
892 if (info != -1)
893 {
894 overwrite = FALSE;
895 if (delHook && (omode != DELMODE_NONE))
896 {
897 if (
898 (omode == DELMODE_ASK) || (omode == DELMODE_DELETE) ||
899 (omode == DELMODE_ALL) || (omode == DELMODE_NO)
900 )
901 {
902 delDisplay.spath = dest;
903 delDisplay.file = FIB->fib_FileName;
904 delDisplay.type = 2;
905 delDisplay.filelen = 0;
906 if (omode != DELMODE_ALL) omode = CallHook(delHook, (Object *) &delDisplay, NULL);
907 if ((omode == DELMODE_ALL) || (omode == DELMODE_DELETE))
908 {
909 if ((info & (FILEINFO_PROTECTED|FILEINFO_WRITE)) !=0)
910 {
911 if (pmode != DELMODE_NONE)
912 {
913 if (
914 (pmode == DELMODE_ASK) || (pmode == DELMODE_DELETE) ||
915 (pmode == DELMODE_ALL) || (pmode == DELMODE_NO)
916 )
917 {
918 delDisplay.spath = dest;
919 delDisplay.file = FIB->fib_FileName;
920 delDisplay.type = 1;
921 delDisplay.filelen = 0;
922 if (pmode != DELMODE_ALL) pmode = CallHook(delHook, (Object *) &delDisplay, NULL);
923 if ((pmode == DELMODE_ALL) || (pmode == DELMODE_DELETE))
924 {
925 overwrite = TRUE;
926 SetProtection(dpath, 0);
927 }
928 }
929 }
930 }
931 else overwrite = TRUE;
932 }
933 }
934 }
935 }
936 }
937 if (dpath) freeString(pool, dpath);
938 }
939
940 failure = FALSE;
941 if (!quit && ((flags & ACTION_COPY) !=0) && overwrite)
942 {
943 display.flags = (flags &= ~ACTION_UPDATE);
944 failure = copyFile(pool, FIB->fib_FileName, dest, FIB, dHook, &display);
945 }
946
947 if (failure && !quit)
948 {
949 if (delHook)
950 {
951 delDisplay.spath = source;
952 delDisplay.file = FIB->fib_FileName;
953 delDisplay.type = 3;
954 delDisplay.filelen = 0;
955 if (CallHook(delHook, (Object *) &delDisplay, NULL) == ACCESS_SKIP)
956 quit = FALSE; else quit = TRUE;
957 }
958 else quit = FALSE;
959 }
960
961 if (!quit && delHook && (dmode != DELMODE_NONE) && ((flags & ACTION_DELETE) !=0))
962 {
963 if (
964 (dmode == DELMODE_ASK) || (dmode == DELMODE_DELETE) ||
965 (dmode == DELMODE_ALL) || (dmode == DELMODE_NO)
966 )
967 {
968 delDisplay.spath = source;
969 delDisplay.file = FIB->fib_FileName;
970 delDisplay.type = 0;
971 delDisplay.filelen = FIB->fib_Size;
972 if (dmode != DELMODE_ALL) dmode = CallHook(delHook, (Object *) &delDisplay, NULL);
973 if ((dmode == DELMODE_ALL) || (dmode == DELMODE_DELETE))
974 {
975
976 info = GetFileInfo(FIB->fib_FileName);
977 unprotect = FALSE;
978 if ((info & (FILEINFO_PROTECTED|FILEINFO_WRITE)) != 0)
979 {
980 if (pmode != DELMODE_NONE)
981 {
982 if (
983 (pmode == DELMODE_ASK) || (pmode == DELMODE_DELETE) ||
984 (pmode == DELMODE_ALL) || (pmode == DELMODE_NO)
985 )
986 {
987 delDisplay.spath = source;
988 delDisplay.file = FIB->fib_FileName;
989 delDisplay.type = 1;
990 delDisplay.filelen = 0;
991 if (pmode != DELMODE_ALL) pmode = CallHook(delHook, (Object *) &delDisplay, NULL);
992 if ((pmode == DELMODE_ALL) || (pmode == DELMODE_DELETE))
993 {
994 unprotect = TRUE;
995 SetProtection(FIB->fib_FileName, 0);
996 }
997 }
998 }
999 }
1000 else unprotect = TRUE;
1001
1002 if (unprotect)
1003 {
1004 if (FIB->fib_FileName)
1005 {
1006 len = strlen(FIB->fib_FileName);
1007 if (len>0)
1008 {
1009
1010 fe = AllocPooled(pool, sizeof(struct FileEntry) + len);
1011 if (fe)
1012 {
1013 strcpy(fe->name, FIB->fib_FileName);
1014 if (fel)
1015 {
1016 fel->next = fe;
1017 fel = fe;
1018 }
1019 else
1020 {
1021 fef = fe;
1022 fel = fe;
1023 }
1024 }
1025 }
1026 }
1027 }
1028 }
1029 }
1030 }
1031
1032 }
1033 }
1034 else
1035 {
1036 DosError=IoErr();
1037 if (DosError!=ERROR_NO_MORE_ENTRIES) Success=TRUE;
1038 }
1039 }
1040 while (Success && !quit);
1041 }
1042
1043 while (fef)
1044 {
1045 len = strlen(fef->name);
1046 if (len > 0)
1047 {
1048 deleteFile(fef->name);
1049 }
1050 fe = fef->next;
1051 FreePooled(pool, fef, sizeof(struct FileEntry) + len);
1052 fef = fe;
1053 }
1054
1055 CurrentDir(cDir);
1056 UnLock(NewLock);
1057 }
1058 FreeDosObject (DOS_FIB,(APTR) FIB2);
1059 }
1060 FreeDosObject (DOS_FIB,(APTR) FIB);
1061 }
1062
1063 return quit;
1064 }
1065 ///
1066
1067 ///CopyContent()
1068 BOOL CopyContent(APTR p, char *s, char *d, BOOL makeparentdir, ULONG flags, struct Hook *displayHook, struct Hook *delHook, APTR userdata)
1069 {
1070
1071 struct FileInfoBlock *FIB;
1072 struct dCopyStruct display;
1073 struct dCopyStruct delDisplay;
1074 char *destname, *dest, *path, *comment, *dpath, *infoname, *destinfo;
1075 //LONG len;
1076 LONG Success2, prot;
1077 BPTR nLock, nDir;
1078 APTR pool;
1079 BOOL created = FALSE;
1080 BOOL dir = TRUE;
1081 BOOL back = FALSE;
1082 BOOL deletesrc, unprotectsrc;
1083 LONG info;
1084 UWORD dmode = DELMODE_ASK;
1085 UWORD pmode = DELMODE_ASK;
1086 UWORD omode = DELMODE_ASK;
1087
1088 if (p == NULL)
1089 {
1090 pool = CreatePool(MEMF_CLEAR|MEMF_ANY, POOLSIZE, POOLSIZE);
1091 }
1092 else pool = p;
1093
1094 if (pool == NULL) return FALSE;
1095
1096 infoname = AllocPooled(pool, strlen(s)+6);
1097 display.userdata = userdata;
1098 delDisplay.userdata = userdata;
1099
1100 if (infoname)
1101 {
1102 strncpy (infoname, s, strlen(s));
1103 strcat(infoname,".info");
1104 }
1105
1106 if (d) destinfo = AllocPooled(pool, strlen(d)+6); else destinfo = NULL;
1107
1108 if (destinfo)
1109 {
1110 strncpy (destinfo, d, strlen(d));
1111 strcat(destinfo,".info");
1112 }
1113
1114 destname = FilePart(s);
1115
1116 info = GetFileInfo(s);
1117
1118 if (info == -1)
1119 {
1120 freeString(pool, infoname);
1121 freeString(pool, destinfo);
1122 if (p == NULL) DeletePool(pool);
1123 return TRUE;
1124 }
1125
1126 if ((info & FILEINFO_DIR) != 0) dir = TRUE; else dir = FALSE;
1127
1128 dest = NULL;
1129
1130 if ((flags & ACTION_COPY) !=0 ) dest = allocString(pool, d);
1131
1132 if (makeparentdir && dir && dest)
1133 {
1134 if (destname)
1135 {
1136 if (strlen(destname)>0)
1137 {
1138 freeString(pool, dest);
1139 dest = NULL;
1140 FIB = (struct FileInfoBlock*) AllocDosObject(DOS_FIB,DummyTags);
1141 if (FIB)
1142 {
1143 dest = combinePath(pool, d, destname);
1144 if (dest)
1145 {
1146 nLock = Lock(dest, ACCESS_READ);
1147 if (nLock)
1148 {
1149 Success2 = Examine(nLock,FIB);
1150 if (Success2) if (FIB->fib_DirEntryType>0) created = TRUE;
1151 UnLock(nLock);
1152 }
1153 if (!created)
1154 {
1155 nDir = CreateDir(dest);
1156 if (nDir)
1157 {
1158 created = TRUE;
1159 UnLock(nDir);
1160 prot = GetProtectionInfo(s);
1161 comment = GetCommentInfo(pool, s);
1162 if (comment) SetComment(dest, comment);
1163 SetProtection(dest, prot);
1164 freeString(pool, comment);
1165 }
1166 }
1167 if (!created)
1168 {
1169 freeString(pool, dest);
1170 dest = NULL;
1171 created = FALSE;
1172 }
1173 }
1174 FreeDosObject (DOS_FIB,(APTR) FIB);
1175 }
1176 }
1177 }
1178 }
1179
1180 path = NULL;
1181
1182 deletesrc = FALSE;
1183 unprotectsrc = TRUE;
1184 if (delHook && ((flags & ACTION_DELETE) != 0) && ((makeparentdir && dir) || !dir))
1185 {
1186 if (dir)
1187 {
1188 delDisplay.spath = s;
1189 delDisplay.file = NULL;
1190 }
1191 else
1192 {
1193 path = allocPath(pool, s);
1194 delDisplay.spath = path;
1195 delDisplay.file = FilePart(s);
1196 }
1197 delDisplay.type = 0;
1198
1199 dmode = CallHook(delHook, (Object *) &delDisplay, NULL);
1200 if ((dmode == DELMODE_ALL) || (dmode == DELMODE_DELETE))
1201 {
1202 deletesrc = TRUE;
1203 if ((info & (FILEINFO_PROTECTED|FILEINFO_WRITE)) != 0)
1204 {
1205 delDisplay.type = 1;
1206 unprotectsrc = FALSE;
1207 pmode = CallHook(delHook, (Object *) &delDisplay, NULL);
1208 if ((pmode == DELMODE_ALL) || (pmode == DELMODE_DELETE))
1209 {
1210 SetProtection(s, 0);
1211 if (infoname) SetProtection(infoname, 0);
1212 unprotectsrc = TRUE;
1213 }
1214 }
1215 }
1216 }
1217
1218 if (dest)
1219 {
1220 if (delHook && !dir)
1221 {
1222 dpath = combinePath(pool, d, FilePart(s));
1223 if (dpath)
1224 {
1225 info = GetFileInfo(dpath);
1226 if (info != -1)
1227 {
1228 if (delHook && (omode != DELMODE_NONE))
1229 {
1230 if (
1231 (omode == DELMODE_ASK) || (omode == DELMODE_DELETE) ||
1232 (omode == DELMODE_ALL) || (omode == DELMODE_NO)
1233 )
1234 {
1235 delDisplay.spath = d;
1236 delDisplay.file = FilePart(s);
1237 delDisplay.type = 2;
1238 if (omode != DELMODE_ALL) omode = CallHook(delHook, (Object *) &delDisplay, NULL);
1239 if ((omode == DELMODE_ALL) || (omode == DELMODE_DELETE))
1240 {
1241 if (((info & (FILEINFO_PROTECTED|FILEINFO_WRITE)) != 0) && (pmode != DELMODE_NONE))
1242 {
1243 if (
1244 (pmode == DELMODE_ASK) || (pmode == DELMODE_DELETE) ||
1245 (pmode == DELMODE_ALL) || (pmode == DELMODE_NO)
1246 )
1247 {
1248 delDisplay.spath = d;
1249 delDisplay.file = FilePart(s);
1250 delDisplay.type = 1;
1251 if (pmode != DELMODE_ALL) pmode = CallHook(delHook, (Object *) &delDisplay, NULL);
1252 if ((pmode == DELMODE_ALL) || (pmode == DELMODE_DELETE))
1253 {
1254 SetProtection(dpath, 0);
1255 }
1256 }
1257 }
1258 }
1259 }
1260 }
1261 }
1262 }
1263 freeString(pool, dpath);
1264 }
1265 freeString(pool, path);
1266 }
1267
1268 if (dir)
1269 {
1270 if (dest || ((flags & ACTION_DELETE) != 0))
1271 {
1272 if (
1273 ((dmode == DELMODE_NONE) || (dmode == DELMODE_NO)) &&
1274 (flags & (ACTION_DELETE|ACTION_COPY)) == ACTION_DELETE
1275 )
1276 {
1277 back = FALSE;
1278 }
1279 else
1280 {
1281 back = actionDir(
1282 pool, flags, s, dest, FALSE, dmode, pmode, omode, displayHook, delHook, userdata
1283 );
1284 }
1285 }
1286 else back = TRUE;
1287 }
1288 else
1289 {
1290 if (flags == ACTION_DELETE) back = FALSE;
1291 else
1292 {
1293 STRPTR path = allocPath(pool, s);
1294 display.file = FilePart(s);
1295 display.filelen = 0;
1296 display.totallen = 0;
1297 display.actlen = 0;
1298
1299 if (path) display.spath = path; else display.spath = s;
1300 display.dpath = d;
1301 display.flags = (flags &= ~ACTION_UPDATE);
1302 if (displayHook) CallHook(displayHook, (Object *) &display, NULL);
1303 back = copyFile(pool, s, d, NULL, displayHook, &display);
1304 if (path) freeString(pool, path);
1305 }
1306 }
1307
1308 if (!back && destinfo && infoname)
1309 {
1310 SetProtection(destinfo, 0);
1311 copyFile(pool, infoname, d, NULL, NULL, NULL);
1312 }
1313
1314 if (!back && delHook && (dmode != DELMODE_NONE) && ((flags & ACTION_DELETE) !=0))
1315 {
1316 if (unprotectsrc && deletesrc)
1317 {
1318 deleteFile(s);
1319 if (infoname) deleteFile(infoname);
1320 }
1321 }
1322
1323 freeString(pool, infoname);
1324 freeString(pool, destinfo);
1325 freeString(pool, dest);
1326
1327 if (p == NULL)
1328 DeletePool(pool);
1329 return !back;
1330 }
1331 ///
A totally sweet operating system