?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Overhauled error-code handling (IoErr() must be called immediately
[AROS.git] / workbench / c / Copy.c
blob884f409eab306f317e17a909b6060ccda1fc466a
1 /*
2 Copyright © 2001-2011, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Copy CLI command
6 Lang: English
7 */
8
9 /*****************************************************************************
10
11 NAME
12
13 Copy
14
15 SYNOPSIS
16
17 FROM/M, TO, ALL/S, QUIET/S, BUF=BUFFER/K/N, CLONE/S, DATES/S, NOPRO/S,
18 COM=COMMENT/S, NOREQ/S,
19
20 PAT=PATTERN/K, DIRECT/S,SILENT/S, ERRWARN/S, MAKEDIR/S, MOVE/S,
21 DELETE/S, HARD=HARDLINK/S, SOFT=SOFTLINK/S, FOLNK=FORCELINK/S,
22 FODEL=FORCEDELETE/S, FOOVR=FORCEOVERWRITE/S, DONTOVR=DONTOVERWRITE/S,
23 FORCE/S,NEWER/S
24
25 LOCATION
26
27 C:
28
29 FUNCTION
30
31 Creates identical copies of one or more files.
32
33 INPUTS
34
35 FROM -- multiple input files
36 TO -- destination file or directory
37 ALL -- deep scan into sub directories
38 QUIET -- suppress all output and requesters
39 BUFFER -- buffer size for copy buffer in 512 byte blocks
40 (default 1024 (= 512K))
41 CLONE -- copy comment, protection bits and date as well
42 DATES -- copy dates
43 NOPRO -- do not copy protection bits
44 COMMENT -- copy file comment
45 NOREQ -- suppress requesters
46
47 PATTERN -- a pattern the filenames must match
48 DIRECT -- copy mode only: copy file without any tests or options
49 VERBOSE -- gives more output
50 ERRWARN -- do not proceed, when one file failed
51 MAKEDIR -- produce directories
52 MOVE -- delete source files after copying successful
53 DELETE -- do not copy, but delete the source files
54 HARDLINK -- make a hardlink to source instead of copying
55 SOFTLINK -- make a softlink to source instead of copying
56 FOLNK -- also makes links to directories
57 FODEL -- delete protected files also
58 FOOVR -- also overwrite protected files
59 DONTOVR -- never overwrite destination
60 FORCE -- DO NOT USE. Call compatibility only.
61 NEWER -- compare version strings and only overwrites older files.
62
63
64 More detailed descriptions:
65
66 FROM:
67 Source file(s). For directories, all contained files are source files. May
68 have standard patterns.
69
70 TO:
71 Destination file or for multiple sources destination directory. Destination
72 directories are created (including all needed parent directories).
73
74 ALL:
75 Scan directories recursively
76
77 QUIET:
78 Copy is completely silent here. Really no output is given, also no requests
79 for missing disks or other problems!
80
81 BUF=BUFFER:
82 Specify the number of 512 byte buffers for copying. Default are 200 buffers
83 [100KB memory]. One buffer is minimum size, but should never be used.
84
85 PAT=PATTERN:
86 PATTERN allows to specify a standard dos pattern, all file have to match.
87 This is useful with ALL option.
88
89 Example:
90 When you want to delete all .info files in a directory tree, you need
91 this option: Copy DELETE #? ALL PAT #?.info
92
93 CLONE:
94 The filecomment, date and protection bits of the source files are copied to
95 destination file or directory.
96
97 DATES:
98 The date information of source is copied to destination.
99
100 NOPRO:
101 The protection bits of sources are NOT copied. So the destination gets
102 default bits [rwed].
103
104 COM=COMMENT:
105 The filecomment is copied to destination.
106
107 NOREQ:
108 No standard DOS requests are displayed, when an error occurs.
109
110
111 DIRECT:
112 Certain devices do not allow some of the used DOS packet request types.
113 This option is a really easy copy command, which only opens source and
114 destination directly without any tests and checks.
115 Options ALL, PAT, CLONE, DATES, NOPRO, COM, MAKEDIR, MOVE, DELETE, HARD,
116 SOFT, FOLNK, FODEL, FOOVR, DONTOVR and multiple input files cannot be
117 specified together with DIRECT. This options needs one input and one output
118 file.
119 When you want to delete a softlink, which does no longer point to a valid
120 file, you need this option as well.
121 Example use: 'Copy DIRECT text PRT:' to print a file called text.
122 - Copy manages a lot of such cases automatically, but maybe this option is
123 needed sometimes.
124
125 VERBOSE:
126 Copy gives additional output.
127
128 ERRWARN:
129 Copy knows and returns the 3 types of dos.library errors:
130 5 WARN The processing of one file failed, Copy skips this file
131 and proceeds the next.
132 10 ERROR The creation of a directory or any other bad error happend.
133 Copy quits after that.
134 20 FAIL A really hard error happend (No memory, Examine failed, ...)
135 Copy quits after that.
136 When option ERRWARN is used, the result 5 (WARN) gets result 10 (ERROR). So
137 Copy aborts everytime an error occured.
138
139 MAKEDIR:
140 All names specified in FROM field are taken as directories, which must be
141 created.
142
143 MOVE:
144 The files are not copied, but moved (or renamed). This means that after
145 move operation the source does no longer exist.
146
147 DELETE:
148 This does not copy anything, but deletes the source files!
149
150 HARD=HARDLINK:
151 Instead of copying the files, a hard link is created. This only works,
152 when destination is on same device as source.
153 When ALL option is specified, the directories are scanned recursively, else
154 Copy produces links to the directories.
155
156 SOFT=SOFTLINK:
157 Instead of copying directories, a soft link is created. These links are
158 useable between different devices also. Soft links are only created for
159 directories. Files are skipped here. Option FORCELINK is therefor always
160 set to true.
161 NOTE: Softlinks are not official supported by OS and may be dangerous.
162 I suggest not to use this option! See description below.
163
164 FOLNK=FORCELINK:
165 When linking of directories should be possible, this option is needed. See
166 section "About links" for possible problems.
167
168 FODEL=FORCEDELETE:
169 When this option is enabled, files are deleted also, when they are delete
170 protected.
171
172 FOOVR=FORCEOVERWRITE:
173 When this option is enabled, files are overwritten also, when they are
174 protected.
175
176 DONTOVR=DONTOVERWRITE:
177 This option prevents overwriting of destination files.
178
179 NEWER:
180 This option scans the version strings of the source and destination files and
181 only overwrites if the source file is newer than the destination file.
182
183 RESULT
184
185 NOTES
186
187 EXAMPLE
188
189 BUGS
190
191 SEE ALSO
192
193 Delete, Rename, MakeDir, MakeLink
194
195 INTERNALS
196
197 The separation of the different switches above is according to
198 what the AmigaDOS Copy command had, and the extensions respectively.
199
200 Some comments on how the program does its job:
201
202 The program has 6 working modes: COPY, MOVE, SOFTLINK, HARDLINK,
203 DELETE and MAKEDIR. Only one of these can be used at same time!
204
205 Move option renames the files, when on same device, else the file
206 is copied and the source deleted after that.
207 When a directory is processed and on the same device it is
208 renamed! This means MOVE option copies complete directories also
209 without ALL option (when on same device).
210
211 In Copy mode you may use f.e. "Copy C: RAM:K" instead of
212 "Copy C:#? RAM:K". For the other modes this does not work!
213
214 Destination files are always overwritten, except DONTOVERWRITE is
215 turned on, or they are protected.
216
217 When the destination directory does not exists, it is created.
218 Existing files with same name are overwritten. When some parent
219 directories do not exist, they are also created. This is also done,
220 when only one file is copied.
221
222 The program does a loop detection, so that copying/moving/linking
223 with a sub directory of source as destination and ALL option is not
224 possible.
225
226 Example: Copy RAM:S RAM:S/C ALL
227
228
229 Useful aliases you may add to S:User-StartUp:
230
231 Alias Delete Copy [] DELETE VERBOSE
232 Alias MakeDir Copy [] MAKEDIR
233 Alias MakeLink Copy TO [] HARDLINK
234 Alias Move Copy [] MOVE CLONE VERBOSE
235 Alias Rename Copy [] MOVE CLONE
236
237 Some programs do want the files to be in C: directory. For these
238 you may additionally use following lines:
239
240 Alias C:Delete Copy [] DELETE VERBOSE
241 Alias C:MakeDir Copy [] MAKEDIR
242 Alias C:MakeLink Copy TO [] HARDLINK
243 Alias C:Rename Copy [] MOVE CLONE
244
245
246 About links:
247
248 HARDLINKS:
249 When copying one file to annother place on same disk, the file
250 afterwards uses double space. Links are a method to resolve that
251 problem. When using a link, the file is not copied, but only a new
252 entry to the same data as created. This saves space and allows to
253 have copies of files always up-to-date (as when on link is updated,
254 all the others are new as well).
255
256 SOFTLINKS:
257 This is a link method, which is NOT official supported by the OS.
258 Soft links do not need to be on the same partition. The may be used
259 for references between different partitions. NOTE: Using this links
260 may cause lots of problems. You may test for yourself if it works for
261 you!
262
263 PROBLEMS:
264 Links to directories may cause infinite directory loops!
265
266 Example: Having following directory tree:
267
268 DEV:
269 / \
270 A B
271
272 Some loops are detected, for example when trying to do:
273 MakeLink DEV:A/C DEV:A FORCE
274 Here you get an error message, that loops are not allowed.
275
276 Some more complicated links cannot be detected:
277 MakeLink DEV:A/C DEV:B FORCE
278 and
279 MakeLink DEV:B/C DEV:A FORCE
280 Till now no error message is possible, so the result is an infinite
281 loop.
282
283
284 HISTORY
285
286 Copy was done by Dirk Stoecker (stoecker@amigaworld.com), donated
287 to AROS in March 2001
288
289 ******************************************************************************/
290
291 #define CTRL_C (SetSignal(0L,0L) & SIGBREAKF_CTRL_C)
292
293 #define DEBUG 0
294 #define D(x)
295
296 #define USE_SOFTLINKCHECK 1
297 #define USE_ALWAYSVERBOSE 1
298 #define USE_BOGUSEOFWORKAROUND 0
299
300 #include <aros/asmcall.h>
301 #include <exec/devices.h>
302 #include <exec/io.h>
303 #include <exec/memory.h>
304 #include <exec/semaphores.h>
305 #include <exec/types.h>
306 #include <dos/exall.h>
307
308 #ifdef __SASC
309 typedef ULONG IPTR;
310 #else /* __SASC */
311 #include <aros/debug.h>
312 #endif /* __SASC */
313
314 #include <proto/dos.h>
315 #include <proto/exec.h>
316
317 #include <string.h>
318
319 const TEXT version[] = "\0$VER: Copy 50.17 (30.12.2011)";
320
321 static const UBYTE *PARAM =
322 "FROM/M,TO,PAT=PATTERN/K,BUF=BUFFER/K/N,ALL/S,"
323 "DIRECT/S,CLONE/S,DATES/S,NOPRO/S,COM=COMMENT/S,"
324 "QUIET/S,"
325 #if !USE_ALWAYSVERBOSE
326 "VERBOSE/S,"
327 #endif
328 "NOREQ/S,ERRWARN/S,MAKEDIR/S,"
329 "MOVE/S,DELETE/S,HARD=HARDLINK/S,SOFT=SOFTLINK/S,"
330 "FOLNK=FORCELINK/S,FODEL=FORCEDELETE/S,"
331 "FOOVR=FORCEOVERWRITE/S,DONTOVR=DONTOVERWRITE/S,"
332 "FORCE/S,NEWER/S";
333
334 #define COPYFLAG_ALL (1<<0)
335 #define COPYFLAG_DATES (1<<1)
336 #define COPYFLAG_NOPRO (1<<2)
337 #define COPYFLAG_COMMENT (1<<3)
338 #define COPYFLAG_FORCELINK (1<<4)
339 #define COPYFLAG_FORCEDELETE (1<<5)
340 #define COPYFLAG_FORCEOVERWRITE (1<<6)
341 #define COPYFLAG_DONTOVERWRITE (1<<7)
342 #define COPYFLAG_QUIET (1<<8)
343 #define COPYFLAG_VERBOSE (1<<9)
344 #define COPYFLAG_ERRWARN (1<<10)
345 #define COPYFLAG_NEWER (1<<11)
346
347 #define COPYFLAG_SOFTLINK (1<<20) /* produce softlinks */
348 #define COPYFLAG_DEST_FILE (1<<21) /* one file mode */
349 #define COPYFLAG_DONE (1<<22) /* did something in DoWork */
350 #define COPYFLAG_ENTERSECOND (1<<23) /* entered directory second time */
351
352 #define COPYFLAG_SRCNOFILESYS (1<<24) /* source is no filesystem */
353 #define COPYFLAG_DESNOFILESYS (1<<25) /* destination is no filesystem */
354
355 #define COPYMODE_COPY 0
356 #define COPYMODE_MOVE 1
357 #define COPYMODE_DELETE 2
358 #define COPYMODE_MAKEDIR 3
359 #define COPYMODE_LINK 4
360
361 #define PRINTOUT_SIZE 50 /* maximum size of name printout */
362 #define PRINTOUT_SPACES 10 /* maximum number of spaces */
363
364 #define FILEPATH_SIZE 2048 /* maximum size of filepaths */
365
366 /* return values */
367 #define TESTDEST_DIR_OK 2 /* directory exists, go in */
368 #define TESTDEST_DELETED 1 /* file or empty directory deleted */
369 #define TESTDEST_NONE 0 /* nothing existed */
370 #define TESTDEST_ERROR -1 /* an error occured */
371 #define TESTDEST_CANTDELETE -2 /* deletion not allowed (DONTOV) */
372
373 struct IptrArgs
374 {
375 IPTR from;
376 IPTR to;
377 IPTR pattern;
378 IPTR buffer;
379 IPTR all;
380 IPTR direct;
381 IPTR clone;
382 IPTR dates;
383 IPTR nopro;
384 IPTR comment;
385 IPTR quiet;
386 #if !USE_ALWAYSVERBOSE
387 IPTR verbose;
388 #endif
389 IPTR noreq;
390 IPTR errwarn;
391 IPTR makedir;
392 IPTR move_mode;
393 IPTR delete_mode;
394 IPTR hardlink;
395 IPTR softlink;
396 IPTR forcelink;
397 IPTR forcedelete;
398 IPTR forceoverwrite;
399 IPTR dontoverwrite;
400 IPTR force;
401 IPTR newer;
402 };
403
404
405 struct Args
406 {
407 STRPTR *from;
408 STRPTR to;
409 STRPTR pattern;
410 LONG *buffer;
411 LONG all;
412 LONG direct;
413 LONG clone;
414 LONG dates;
415 LONG nopro;
416 LONG comment;
417 LONG quiet;
418 LONG verbose;
419 LONG noreq;
420 LONG errwarn;
421 LONG makedir;
422 LONG move_mode;
423 LONG delete_mode;
424 LONG hardlink;
425 LONG softlink;
426 LONG forcelink;
427 LONG forcedelete;
428 LONG forceoverwrite;
429 LONG dontoverwrite;
430 LONG force;
431 LONG newer;
432 };
433
434
435 struct CopyData
436 {
437 struct ExecBase *SysBase;
438 struct DosLibrary *DOSBase;
439
440 ULONG Flags;
441 ULONG BufferSize;
442 STRPTR Pattern;
443 BPTR Destination;
444 BPTR CurDest; /* Current Destination */
445 ULONG DestPathSize;
446 struct FileInfoBlock Fib;
447 UBYTE Mode;
448 UBYTE RetVal; /* when set, error output is already done */
449 UBYTE RetVal2; /* when set, error output must be done */
450 LONG IoErr;
451 UBYTE Deep;
452 UBYTE FileName[FILEPATH_SIZE];
453 UBYTE DestName[FILEPATH_SIZE];
454
455 STRPTR CopyBuf;
456 ULONG CopyBufLen;
457 };
458
459 /*
460 ** This data keeps the extracted data from a version string
461 */
462
463 #define VDNAMESIZE 96
464
465 struct VersionData {
466 UBYTE vd_Name[VDNAMESIZE];
467 LONG vd_Version;
468 LONG vd_Revision;
469
470 LONG vd_Day;
471 LONG vd_Month;
472 LONG vd_Year;
473 };
474
475 #ifndef MIN
476 #define MIN(a,b) ((a)<(b)?(a):(b))
477 #endif
478
479 #define CHECKVER_DESTOLDER -1
480 #define CHECKVER_DESTNEWER 1
481 #define CHECKVER_EQUAL 0
482
483 #define TEXT_READ texts[0]
484 #define TEXT_COPIED texts[1]
485 #define TEXT_MOVED texts[2]
486 #define TEXT_DELETED texts[3]
487 #define TEXT_LINKED texts[4]
488 #define TEXT_RENAMED texts[5]
489 #define TEXT_CREATED texts[6]
490 #define TEXT_ENTERED texts[7]
491 #define TEXT_OPENED_FOR_OUTPUT texts[8]
492 #define TEXTNUM_MODE 9
493 #define TEXT_DIRECTORY texts[15]
494 #define TEXT_NOT_DONE texts[16]
495 #define TEXT_NOTHING_DONE texts[17]
496 #define TEXT_ERR_FORCELINK texts[18]
497 #define TEXT_ERR_DELETE_DEVICE texts[19]
498 #define TEXT_ERR_DEST_DIR texts[20]
499 #define TEXT_ERR_INFINITE_LOOP texts[21]
500 #define TEXT_ERR_WILDCARD_DEST texts[22]
501
502 const CONST_STRPTR texts[] =
503 {
504 "read.",
505 "copied",
506 "moved",
507 "deleted",
508 "linked",
509 "renamed",
510 " [created]",
511 "entered",
512 "opened for output",
513 "COPY mode\n",
514 "MOVE mode\n",
515 "DELETE mode\n",
516 "MAKEDIR mode\n",
517 "HARDLINK mode\n",
518 "SOFTLINK mode\n",
519 "%s (Dir)", /* output of directories */
520 " not %s",
521 "No file was processed.\n",
522 "FORCELINK keyword required.\n",
523 "A device cannot be deleted.",
524 "Destination must be a directory.\n",
525 "Infinite loop not allowed.\n",
526 "Wildcard destination invalid.\n",
527 };
528
529 LONG CopyFile(BPTR, BPTR, ULONG, struct CopyData *);
530 void DoWork(STRPTR, struct CopyData *);
531 LONG IsMatchPattern(STRPTR name, struct CopyData *cd);
532 LONG IsPattern(STRPTR, struct CopyData *); /* return 0 -> NOPATTERN, return -1 --> ERROR */
533 LONG KillFile(STRPTR, ULONG, struct CopyData *);
534 LONG KillFileKeepErr(STRPTR name, ULONG doit, struct CopyData *);
535 LONG LinkFile(BPTR, STRPTR, ULONG, struct CopyData *);
536 BPTR OpenDestDir(STRPTR, struct CopyData *);
537 void PatCopy(STRPTR, struct CopyData *);
538 void PrintName(CONST_STRPTR, ULONG, ULONG, ULONG, struct CopyData *);
539 void PrintNotDone(CONST_STRPTR, CONST_STRPTR, ULONG, ULONG, struct CopyData *);
540 ULONG TestFileSys(STRPTR, struct CopyData *); /* returns value, when is a filesystem */
541 void SetData(STRPTR, struct CopyData *);
542 LONG TestDest(STRPTR, ULONG, struct CopyData *);
543 ULONG TestLoop(BPTR, BPTR, struct CopyData *);
544 static LONG CheckVersion( struct CopyData *cd );
545 static void makeversionfromstring( STRPTR buffer, struct VersionData *vd, struct CopyData *cd);
546 static STRPTR skipspaces( STRPTR buffer);
547 static STRPTR skipnonspaces( STRPTR buffer);
548 static BOOL VersionFind( CONST_STRPTR path, struct VersionData *vds, struct CopyData *cd);
549
550 __startup static AROS_ENTRY(int, Start,
551 AROS_UFHA(char *, argstr, A0),
552 AROS_UFHA(ULONG, argsize, D0),
553 struct ExecBase *, SysBase)
554 {
555 AROS_USERFUNC_INIT
556
557 struct DosLibrary *DOSBase;
558 struct Process *task;
559 struct CopyData *cd;
560 int retval = RETURN_FAIL;
561
562 /* test for WB and reply startup-message */
563 if (!(task = (struct Process *)FindTask(NULL))->pr_CLI)
564 {
565 WaitPort(&task->pr_MsgPort);
566 Forbid();
567 ReplyMsg(GetMsg(&task->pr_MsgPort));
568
569 return RETURN_FAIL;
570 }
571
572 DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37);
573 cd = AllocMem(sizeof(*cd), MEMF_PUBLIC | MEMF_CLEAR);
574
575 if (DOSBase && cd)
576 {
577 STRPTR a[2] = { "", 0 };
578 struct RDArgs *rda;
579 struct IptrArgs iArgs;
580 struct Args args = {};
581
582 cd->SysBase = SysBase;
583 cd->DOSBase = DOSBase;
584 #define SysBase cd->SysBase
585 #define DOSBase cd->DOSBase
586
587 cd->BufferSize = 512*1024;
588 cd->Mode = COPYMODE_COPY;
589 cd->RetVal2 = RETURN_FAIL;
590 cd->Deep = 1;
591
592 memset(&iArgs, 0, sizeof(struct IptrArgs));
593
594 rda = (struct RDArgs *)AllocDosObject(DOS_RDARGS, NULL);
595 if (rda)
596 {
597 rda->RDA_ExtHelp =
598 "FROM multiple input files\n"
599 "TO destination file or directory\n"
600 "PATTERN a pattern the filenames must match\n"
601 "BUFFER buffersize for copy buffer (default 200 [100K])\n"
602 "ALL deep scan into sub directories\n"
603 "DIRECT copy/delete only: work without any tests or options\n"
604 "CLONE copy comment, protection bits and date as well\n"
605 "DATES copy dates\n"
606 "NOPRO do not copy protection bits\n"
607 "COMMENT copy filecomment\n"
608 "QUIET suppress all output and requesters\n"
609 #if !USE_ALWAYSVERBOSE
610 "VERBOSE give additional output\n"
611 #endif
612 "NOREQ suppress requesters\n"
613 "ERRWARN do not proceed, when one file failed\n"
614 "MAKEDIR produce directories\n"
615 "MOVE delete source files after copying successful\n"
616 "DELETE do not copy, but delete the source files\n"
617 "HARDLINK make a hardlink to source instead of copying\n"
618 "SOFTLINK make a softlink to source instead of copying\n"
619 "FOLNK also makes links to directories\n"
620 "FODEL delete protected files also\n"
621 "FOOVR also overwrite protected files\n"
622 "DONTOVR do never overwrite destination\n"
623 "FORCE DO NOT USE. Call compatibility only.\n"
624 "NEWER will compare version strings and only overwrites older files\n";
625
626 if (ReadArgs(PARAM, (IPTR *)&iArgs, rda))
627 {
628 ULONG patbufsize = 0;
629 LONG i = 0;
630 APTR win = task->pr_WindowPtr;
631
632 args.from = (STRPTR *)iArgs.from;
633 args.to = (STRPTR)iArgs.to;
634 args.pattern = (STRPTR)iArgs.pattern;
635 args.buffer = (LONG *)iArgs.buffer;
636 args.all = (LONG)iArgs.all;
637 args.direct = (LONG)iArgs.direct;
638 args.clone = (LONG)iArgs.clone;
639 args.dates = (LONG)iArgs.dates;
640 args.nopro = (LONG)iArgs.nopro;
641 args.comment = (LONG)iArgs.comment;
642 args.quiet = (LONG)iArgs.quiet;
643 #if USE_ALWAYSVERBOSE
644 args.verbose = FALSE;
645 #else
646 args.verbose = (LONG)iArgs.verbose;
647 #endif
648 args.noreq = (LONG)iArgs.noreq;
649 args.errwarn = (LONG)iArgs.errwarn;
650 args.makedir = (LONG)iArgs.makedir;
651 args.move_mode = (LONG)iArgs.move_mode;
652 args.delete_mode = (LONG)iArgs.delete_mode;
653 args.hardlink = (LONG)iArgs.hardlink;
654 args.softlink = (LONG)iArgs.softlink;
655 args.forcelink = (LONG)iArgs.forcelink;
656 args.forcedelete = (LONG)iArgs.forcedelete;
657 args.forceoverwrite = (LONG)iArgs.forceoverwrite;
658 args.dontoverwrite = (LONG)iArgs.dontoverwrite;
659 args.force = (LONG)iArgs.force;
660 args.newer = (LONG)iArgs.newer;
661
662 if (args.quiet) /* when QUIET, SILENT and NOREQ are also
663 true! */
664 {
665 /* Original doesn't hide requesters with QUIET */
666 /*args.noreq = 1;*/
667 args.verbose = FALSE;
668 }
669
670 if (args.buffer && *args.buffer > 0) /* minimum buffer size */
671 {
672 cd->BufferSize = *args.buffer * 512;
673 }
674
675 if (args.quiet)
676 {
677 cd->Flags |= COPYFLAG_QUIET;
678 }
679
680 #if !USE_ALWAYSVERBOSE
681 if (args.verbose)
682 {
683 cd->Flags |= COPYFLAG_VERBOSE;
684 }
685 #endif
686 if (args.all)
687 {
688 cd->Flags |= COPYFLAG_ALL;
689 }
690
691 if (args.clone)
692 {
693 cd->Flags |= COPYFLAG_DATES | COPYFLAG_COMMENT;
694 }
695
696 if (args.dates)
697 {
698 cd->Flags |= COPYFLAG_DATES;
699 }
700
701 if (args.comment)
702 {
703 cd->Flags |= COPYFLAG_COMMENT;
704 }
705
706 if (args.nopro)
707 {
708 cd->Flags |= COPYFLAG_NOPRO;
709 }
710
711 if (args.forcelink)
712 {
713 cd->Flags |= COPYFLAG_FORCELINK;
714 }
715
716 if (args.forcedelete)
717 {
718 cd->Flags |= COPYFLAG_FORCEDELETE;
719 }
720
721 if (args.forceoverwrite)
722 {
723 cd->Flags |= COPYFLAG_FORCEOVERWRITE;
724 }
725
726 if (args.dontoverwrite)
727 {
728 cd->Flags |= COPYFLAG_DONTOVERWRITE;
729 }
730
731 if (args.newer)
732 {
733 cd->Flags |= COPYFLAG_NEWER|COPYFLAG_DONTOVERWRITE;
734 }
735
736 if (args.errwarn)
737 {
738 cd->Flags |= COPYFLAG_ERRWARN;
739 }
740
741 if (args.force) /* support OS Delete and MakeLink command
742 options */
743 {
744 if (args.delete_mode)
745 {
746 cd->Flags |= COPYFLAG_FORCEDELETE;
747 }
748
749 if (args.hardlink || args.softlink)
750 {
751 cd->Flags |= COPYFLAG_FORCELINK;
752 }
753 }
754
755 if (!args.from) /* no args.from means currentdir */
756 {
757 args.from = a;
758 }
759
760 if (args.noreq) /* no dos.library requests allowed */
761 {
762 task->pr_WindowPtr = (APTR)-1;
763 }
764
765 if (args.delete_mode)
766 {
767 ++i;
768 cd->Mode = COPYMODE_DELETE;
769 }
770
771 if (args.move_mode)
772 {
773 ++i;
774 cd->Mode = COPYMODE_MOVE;
775 }
776
777 if (args.makedir)
778 {
779 ++i;
780 cd->Mode = COPYMODE_MAKEDIR;
781 }
782
783 if (args.hardlink)
784 {
785 ++i;
786 cd->Mode = COPYMODE_LINK;
787 }
788
789 if (args.softlink)
790 {
791 ++i;
792 cd->Mode = COPYMODE_LINK;
793 cd->Flags |= COPYFLAG_SOFTLINK | COPYFLAG_FORCELINK;
794 }
795
796 if (cd->Mode != COPYMODE_DELETE &&
797 cd->Mode != COPYMODE_MAKEDIR && !args.to)
798 {
799 if (*(args.from + 1)) /* when no TO is specified, the arg
800 is last */
801 { /* one of from. Copy this argument into */
802 STRPTR *a; /* args.to */
803
804 a = args.from;
805
806 while(*(++a))
807 ;
808
809 args.to = *(--a);
810 *a = 0;
811 }
812 }
813 #if USE_ALWAYSVERBOSE
814
815 /* Only do this if quiet isn't set - bigfoot */
816 if (!args.quiet)
817 {
818 /* If more than two args, be verbose... - Piru */
819 if (args.from[0] && args.from[1])
820 {
821 args.verbose = TRUE;
822 cd->Flags |= COPYFLAG_VERBOSE;
823 }
824
825 /* If any of the sources is a pattern, be verbose... - Piru */
826 {
827 STRPTR *a;
828
829 for (a = args.from; *a; a++)
830 {
831 if (IsMatchPattern(*a, cd) != 0)
832 {
833 args.verbose = TRUE;
834 cd->Flags |= COPYFLAG_VERBOSE;
835 }
836 }
837 }
838 }
839 #endif
840
841 /* test if more than one of the above four or any other wrong
842 arguments */
843
844 if (i > 1 ||
845 (args.from == a && cd->Mode == COPYMODE_MAKEDIR) ||
846 (args.direct && (args.from == a || !*args.from ||
847 args.pattern ||
848 (cd->Flags & ~(COPYFLAG_QUIET | COPYFLAG_VERBOSE | COPYFLAG_ERRWARN)) ||
849 (cd->Mode != COPYMODE_DELETE && (cd->Mode != COPYMODE_COPY ||
850 !args.to || args.from[1])))) ||
851 (args.dontoverwrite && args.forceoverwrite) ||
852 /* (args.nopro && args.clone) ||*/ /* Ignore, like original - Piru */
853 (args.softlink && args.all) ||
854 (!args.to && cd->Mode != COPYMODE_DELETE && cd->Mode != COPYMODE_MAKEDIR))
855 {
856 cd->IoErr = ERROR_TOO_MANY_ARGS;
857 }
858 else if (cd->Mode == COPYMODE_MAKEDIR)
859 {
860 LONG i;
861 BPTR dir;
862 cd->RetVal2 = RETURN_OK;
863
864 #if !USE_ALWAYSVERBOSE
865 if (args.verbose)
866 {
867 PutStr(texts[TEXTNUM_MODE + COPYMODE_MAKEDIR]);
868 }
869 #endif
870
871 while (!cd->RetVal && !cd->RetVal2 && *args.from)
872 {
873 if ((i = IsPattern(*args.from, cd)))
874 {
875 if (i != -1)
876 {
877 cd->RetVal = RETURN_ERROR;
878
879 if (!args.quiet)
880 {
881 PutStr(TEXT_ERR_WILDCARD_DEST);
882 }
883 }
884 else
885 {
886 cd->RetVal2 = RETURN_FAIL;
887 }
888 }
889
890 if ((dir = OpenDestDir(*args.from, cd)))
891 {
892 UnLock(dir);
893 cd->Flags |= COPYFLAG_DONE;
894 }
895
896 ++args.from;
897 }
898 } /* cd->Mode == COPYMODE_MAKEDIR */
899 else if (args.direct)
900 {
901 if (cd->Mode == COPYMODE_COPY)
902 {
903 BPTR in, out;
904
905 if ((in = Open(*args.from, MODE_OLDFILE)))
906 {
907 if ((out = Open(args.to, MODE_NEWFILE)))
908 {
909 cd->RetVal2 = CopyFile(in, out, cd->BufferSize, cd);
910 if (cd->RetVal2 != 0)
911 cd->IoErr = IoErr();
912 Close(out);
913 }
914 else
915 cd->IoErr = IoErr();
916
917 Close(in);
918 }
919 else
920 cd->IoErr = IoErr();
921 }
922 else /* COPYMODE_DELETE */
923 {
924 while (*args.from)
925 {
926 KillFile(*(args.from++), cd->Flags & COPYFLAG_FORCEDELETE, cd);
927 }
928
929 cd->RetVal2 = RETURN_OK;
930 }
931 }
932 else
933 {
934 if (args.pattern && *args.pattern)
935 {
936 patbufsize = (strlen(args.pattern) << 1) + 3;
937
938 if ((cd->Pattern = (STRPTR)AllocMem(patbufsize,
939 MEMF_ANY)))
940 {
941 if (ParsePatternNoCase(args.pattern, cd->Pattern,
942 patbufsize) < 0)
943 {
944 FreeMem(cd->Pattern, patbufsize);
945 cd->Pattern = 0;
946 }
947 }
948 }
949
950 if (1) // (cd->Fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
951 {
952 #if !USE_ALWAYSVERBOSE
953 if (args.verbose)
954 {
955 PutStr(texts[TEXTNUM_MODE + cd->Mode +
956 (cd->Flags & COPYFLAG_SOFTLINK ? 1 : 0)]);
957 }
958 #endif
959 if (args.pattern && !cd->Pattern)
960 {
961 if (!*args.pattern)
962 {
963 cd->IoErr = ERROR_BAD_TEMPLATE;
964 }
965 }
966 else if (cd->Mode == COPYMODE_DELETE)
967 {
968 cd->RetVal2 = RETURN_OK;
969
970 while (cd->RetVal <= (args.errwarn ? RETURN_OK : RETURN_WARN)
971 && *args.from)
972 {
973 PatCopy(*(args.from++), cd);
974 }
975 }
976 else if ((i = IsPattern(args.to, cd)))
977 {
978 if (i != -1)
979 {
980 cd->RetVal = RETURN_ERROR;
981
982 if (!args.quiet)
983 {
984 PutStr(TEXT_ERR_WILDCARD_DEST);
985 }
986 }
987 }
988 else
989 {
990 STRPTR path;
991
992 if (*(path = PathPart(args.to)) == '/')
993 {
994 ++path; /* is destination a path description ? */
995 }
996
997 if (*path && !*(args.from+1) &&
998 !(i = IsMatchPattern(*args.from, cd)))
999 {
1000 BPTR lock;
1001
1002 /* is destination an existing directory */
1003 if ((lock = Lock(args.to, SHARED_LOCK)))
1004 {
1005 if (Examine(lock, &cd->Fib))
1006 {
1007 if (cd->Fib.fib_DirEntryType > 0)
1008 {
1009 cd->RetVal2 = RETURN_OK;
1010 }
1011
1012 /* indicate dir-mode for next if */
1013 }
1014 else
1015 {
1016 i = 1;
1017 }
1018
1019 UnLock(lock);
1020 }
1021
1022 /* Some magic to handle tick quoted pattern object names. Quite crude way to
1023 * handle it, but I couldn't think of anything better. - Piru
1024 */
1025 #if 1
1026 if (!i && cd->RetVal2 && !IsMatchPattern(*args.from, cd))
1027 {
1028 ULONG len;
1029 STRPTR pat;
1030
1031 //Printf("pattern check <%s>\n", *args.from);
1032
1033 len = (strlen(*args.from) << 1) + 3;
1034
1035 if ((pat = (STRPTR)AllocMem(len,
1036 MEMF_ANY)))
1037 {
1038 if (ParsePattern(*args.from, pat, len) > -1 &&
1039 strlen(pat) <= strlen(*args.from))
1040 {
1041 lock = Lock(pat, SHARED_LOCK);
1042 if (lock)
1043 {
1044 UnLock(lock);
1045
1046 strcpy(*args.from, pat);
1047 }
1048 }
1049
1050 FreeMem(pat, len);
1051 }
1052 }
1053 #endif
1054
1055 /* is source a directory */
1056 if (!i && cd->RetVal2 &&
1057 (lock = Lock(*args.from, SHARED_LOCK)))
1058 {
1059 if (Examine(lock, &cd->Fib))
1060 {
1061 cd->RetVal2 = RETURN_OK;
1062 if (cd->Mode != COPYMODE_COPY ||
1063 cd->Fib.fib_DirEntryType < 0)
1064 {
1065 UBYTE sep;
1066
1067 cd->Flags |= COPYFLAG_DEST_FILE;
1068
1069 /* produce missing destination directories */
1070 sep = *path;
1071 *path = 0;
1072
1073 if ((cd->CurDest = OpenDestDir(args.to, cd)))
1074 {
1075 *path = sep;
1076
1077 /* do the job */
1078 UnLock(lock);
1079 lock = 0;
1080 CopyMem(*args.from, cd->FileName,
1081 1 + strlen(*args.from));
1082 DoWork(FilePart(args.to), cd); /* on file call */
1083 UnLock(cd->CurDest);
1084 }
1085 }
1086 }
1087
1088 if (lock)
1089 {
1090 UnLock(lock);
1091 }
1092 }
1093
1094 if (lock == 0 && cd->Mode == COPYMODE_COPY && !TestFileSys(*args.from, cd))
1095 {
1096 UBYTE sep;
1097 cd->Flags |= COPYFLAG_DEST_FILE | COPYFLAG_SRCNOFILESYS;
1098 cd->RetVal2 = RETURN_OK;
1099
1100 /* produce missing destination directories */
1101 sep = *path;
1102 *path = 0;
1103
1104 if ((cd->CurDest = OpenDestDir(args.to, cd)))
1105 {
1106 *path = sep;
1107
1108 /* do the job */
1109 CopyMem(*args.from, cd->FileName, 1 + strlen(*args.from));
1110 DoWork(FilePart(args.to), cd); /* on file call */
1111 UnLock(cd->CurDest);
1112 }
1113 }
1114 }
1115 else if (i != -1)
1116 {
1117 cd->RetVal2 = RETURN_OK;
1118 }
1119
1120 if (!cd->RetVal && !cd->RetVal2 && !(cd->Flags & COPYFLAG_DEST_FILE) &&
1121 (cd->Destination = OpenDestDir(args.to, cd)))
1122 {
1123 while (cd->RetVal <= (args.errwarn ? RETURN_OK : RETURN_WARN)
1124 && *args.from && !CTRL_C)
1125 {
1126 PatCopy(*(args.from++), cd);
1127 }
1128
1129 UnLock(cd->Destination);
1130 }
1131 } /* else */
1132
1133 if (!(cd->Flags & COPYFLAG_DONE) && args.verbose &&
1134 !cd->RetVal && !cd->RetVal2)
1135 {
1136 PutStr(TEXT_NOTHING_DONE);
1137 }
1138
1139 } /* if (1) */
1140
1141 if (cd->Pattern)
1142 {
1143 FreeMem(cd->Pattern, patbufsize);
1144 }
1145 } /* else */
1146
1147 task->pr_WindowPtr = win;
1148
1149 FreeArgs(rda);
1150 } /* ReadArgs */
1151
1152 FreeDosObject(DOS_RDARGS, rda);
1153 } /* AllocDosObject */
1154
1155 if (!cd->RetVal2 && CTRL_C)
1156 {
1157 SetIoErr(ERROR_BREAK);
1158 cd->RetVal2 = RETURN_WARN;
1159 }
1160
1161 if (cd->RetVal)
1162 {
1163 cd->RetVal2 = cd->RetVal;
1164 }
1165
1166 if (args.errwarn && cd->RetVal2 == RETURN_WARN)
1167 {
1168 cd->RetVal2 = RETURN_ERROR;
1169 }
1170
1171 if (cd->CopyBuf)
1172 {
1173 FreeMem(cd->CopyBuf, cd->CopyBufLen);
1174 }
1175
1176 #undef SysBase
1177 #undef DOSBase
1178 }
1179 if (cd)
1180 {
1181 retval = cd->RetVal2;
1182 SetIoErr(cd->IoErr);
1183 FreeMem(cd, sizeof(*cd));
1184 }
1185 else if (DOSBase)
1186 {
1187 PrintFault(IoErr(), NULL);
1188 }
1189 if (DOSBase)
1190 {
1191 CloseLibrary((struct Library *)DOSBase);
1192 }
1193 return retval;
1194
1195 AROS_USERFUNC_EXIT
1196 }
1197
1198 /* This code is pure and has library bases in explicitly allocated data structure */
1199 #define SysBase cd->SysBase
1200 #define DOSBase cd->DOSBase
1201
1202 void PatCopy(STRPTR name, struct CopyData *cd)
1203 {
1204 struct AnchorPath *APath;
1205 ULONG retval, doit = 0, deep = 0, failval = RETURN_WARN, first = 0;
1206
1207 #if DEBUG
1208 Printf("PatCopy(%s, .)\n", name);
1209 #endif
1210
1211 if ((cd->Mode == COPYMODE_COPY || (cd->Flags & COPYFLAG_ALL)) && !IsMatchPattern(name, cd))
1212 {
1213 first = 1; /* enter first directory (support of old copy style) */
1214 }
1215
1216 if (cd->Flags & COPYFLAG_ERRWARN)
1217 {
1218 failval = RETURN_OK;
1219 }
1220
1221 cd->CurDest = cd->Destination;
1222 cd->DestPathSize = 0;
1223
1224 if (cd->Mode == COPYMODE_COPY && !TestFileSys(name, cd))
1225 {
1226 cd->Flags |= COPYFLAG_SRCNOFILESYS;
1227 CopyMem(name, cd->FileName, 1 + strlen(name));
1228 DoWork(FilePart(name), cd);
1229 cd->Flags &= ~COPYFLAG_SRCNOFILESYS;
1230
1231 return;
1232 }
1233
1234 if ((APath = (struct AnchorPath *)AllocMem(sizeof(struct AnchorPath) + FILEPATH_SIZE,
1235 MEMF_PUBLIC | MEMF_CLEAR)))
1236 {
1237 int parentdirerr = 0;
1238
1239 APath->ap_BreakBits = SIGBREAKF_CTRL_C;
1240 APath->ap_Strlen = FILEPATH_SIZE;
1241
1242 for (retval = MatchFirst(name, APath);
1243 !retval && cd->RetVal <= failval && !cd->RetVal2;
1244 retval = MatchNext(APath)
1245 )
1246 {
1247 if (parentdirerr)
1248 {
1249 //Printf("ParentDir() fuxored last round! Would copy next files to SYS: !\n");
1250 retval = IoErr();
1251 if (!retval)
1252 cd->IoErr = retval = ERROR_INVALID_LOCK;
1253 break;
1254 }
1255
1256 if (doit)
1257 {
1258 DoWork(cd->Fib.fib_FileName, cd);
1259 doit = 0;
1260 }
1261
1262 if (deep) /* used for Deep checking */
1263 {
1264 ++cd->Deep;
1265 deep = 0;
1266 }
1267
1268 cd->Flags &= ~COPYFLAG_ENTERSECOND;
1269
1270 CopyMem(APath->ap_Buf, cd->FileName, FILEPATH_SIZE);
1271 CopyMem(&APath->ap_Info, &cd->Fib, sizeof(struct FileInfoBlock));
1272
1273 if (first && APath->ap_Info.fib_DirEntryType > 0)
1274 {
1275 #if USE_ALWAYSVERBOSE
1276 /* If the source is a directory, be verbose - Piru */
1277 cd->Flags |= COPYFLAG_VERBOSE;
1278 #endif
1279 APath->ap_Flags |= APF_DODIR;
1280 }
1281 else if (APath->ap_Flags & APF_DIDDIR)
1282 {
1283 BPTR i;
1284
1285 cd->Flags |= COPYFLAG_ENTERSECOND;
1286 APath->ap_Flags &= ~APF_DIDDIR;
1287 --cd->Deep;
1288
1289 if (cd->Mode == COPYMODE_DELETE || cd->Mode == COPYMODE_MOVE)
1290 {
1291 doit = 1;
1292 }
1293
1294 if ((i = cd->CurDest))
1295 {
1296 cd->CurDest = ParentDir(i);
1297 cd->DestPathSize = 0;
1298
1299 if (i != cd->Destination)
1300 {
1301 UnLock(i);
1302 }
1303
1304 if (!cd->CurDest)
1305 {
1306 parentdirerr = 1;
1307 continue;
1308 }
1309 }
1310 }
1311 else if (APath->ap_Info.fib_DirEntryType > 0)
1312 {
1313 doit = 1;
1314
1315 if (cd->Flags & COPYFLAG_ALL)
1316 {
1317 BOOL enter;
1318
1319 #if USE_SOFTLINKCHECK
1320
1321 #define BUFFERSIZE 512
1322 if (APath->ap_Info.fib_DirEntryType == ST_SOFTLINK)
1323 {
1324 UBYTE *buffer = AllocMem(BUFFERSIZE, MEMF_PUBLIC);
1325
1326 D(Printf("%s is a softlink\n", APath->ap_Info.fib_FileName));
1327 enter = FALSE;
1328 doit = FALSE;
1329
1330 if (buffer)
1331 {
1332 struct DevProc *dvp = GetDeviceProc("", NULL);
1333
1334 if (ReadLink(dvp->dvp_Port, APath->ap_Current->an_Lock, APath->ap_Info.fib_FileName, buffer, BUFFERSIZE - 1) > 0)
1335 {
1336 BOOL link_ok = FALSE;
1337 BPTR dir, lock;
1338
1339 buffer[BUFFERSIZE - 1] = '\0';
1340 D(Printf("Softlink target: %s\n", buffer));
1341
1342 dir = CurrentDir(APath->ap_Current->an_Lock);
1343 lock = Lock(buffer, SHARED_LOCK);
1344 if (lock)
1345 {
1346 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
1347
1348 if (fib)
1349 {
1350 if (Examine(lock, fib))
1351 {
1352 link_ok = TRUE;
1353 D(Printf("Target type: %ld\n", fib->fib_DirEntryType));
1354
1355 if (fib->fib_DirEntryType > 0)
1356 enter = TRUE;
1357 else
1358 /*
1359 * FIXME: This currently just prevents treating symlinks to files as
1360 * directories during copying.
1361 * DoWork() should be extended to handle symlinks correctly. BTW, how exactly ?
1362 */
1363 doit = FALSE;
1364 }
1365 FreeDosObject(DOS_FIB, fib);
1366 }
1367 UnLock(lock);
1368 }
1369
1370 CurrentDir(dir);
1371
1372 if (!link_ok)
1373 {
1374 Printf("Warning: Skipping dangling softlink %s -> %s\n",
1375 APath->ap_Info.fib_FileName, buffer);
1376 }
1377 }
1378 FreeDeviceProc(dvp);
1379 FreeMem(buffer, BUFFERSIZE);
1380 }
1381 }
1382 else
1383 #endif /* USE_SOFTLINKCHECK */
1384 enter = TRUE;
1385
1386 if (enter)
1387 {
1388 APath->ap_Flags |= APF_DODIR;
1389 deep = 1;
1390 }
1391 }
1392 }
1393 else if (!cd->Pattern || MatchPatternNoCase(cd->Pattern, APath->ap_Info.fib_FileName))
1394 {
1395 doit = 1;
1396 }
1397
1398 first = 0;
1399 }
1400
1401 MatchEnd(APath);
1402
1403 if (retval && retval != ERROR_NO_MORE_ENTRIES)
1404 {
1405 LONG ioerr = IoErr();
1406 #if USE_ALWAYSVERBOSE
1407 cd->Flags |= COPYFLAG_VERBOSE;
1408 #endif
1409 Printf("%s - ", APath->ap_Info.fib_FileName);
1410 PrintFault(ioerr, NULL);
1411 cd->IoErr = ioerr;
1412
1413 cd->RetVal2 = RETURN_FAIL;
1414 }
1415
1416 if (doit)
1417 {
1418 DoWork(cd->Fib.fib_FileName, cd);
1419 }
1420
1421 /* No need to clear the flags here, as they are cleared on next PatJoin
1422 call (DoWork is not called first round, as lock is zero!). */
1423
1424 FreeMem(APath, sizeof(struct AnchorPath) + FILEPATH_SIZE);
1425 }
1426 else
1427 {
1428 cd->RetVal = RETURN_FAIL;
1429
1430 if (!(cd->Flags & COPYFLAG_QUIET))
1431 {
1432 PrintFault(ERROR_NO_FREE_STORE, NULL);
1433 }
1434 }
1435
1436 if (cd->CurDest && cd->CurDest != cd->Destination)
1437 {
1438 UnLock(cd->CurDest);
1439 }
1440 }
1441
1442
1443 LONG IsPattern(STRPTR name, struct CopyData *cd)
1444 {
1445 LONG a, ret = -1;
1446 STRPTR buffer;
1447
1448 a = (strlen(name) << 1) + 3;
1449
1450 if ((buffer = (STRPTR)AllocMem(a, MEMF_ANY)))
1451 {
1452 ret = ParsePattern(name, buffer, a);
1453 FreeMem(buffer, a);
1454 }
1455
1456 if (ret == -1)
1457 {
1458 cd->IoErr = ERROR_NO_FREE_STORE;
1459 }
1460
1461 return ret;
1462 }
1463
1464
1465 LONG IsMatchPattern(STRPTR name, struct CopyData *cd)
1466 {
1467 struct AnchorPath ap;
1468 LONG ret = -1;
1469
1470 ap.ap_BreakBits = 0;
1471 ap.ap_Flags = APF_DOWILD;
1472 ap.ap_Strlen = 0;
1473
1474 if (MatchFirst(name, &ap) == 0)
1475 {
1476 ret = (ap.ap_Flags & APF_ITSWILD) ? TRUE : FALSE;
1477
1478 MatchEnd(&ap);
1479 }
1480
1481 return ret;
1482 }
1483
1484
1485 LONG KillFile(STRPTR name, ULONG doit, struct CopyData *cd)
1486 {
1487 if (doit)
1488 {
1489 SetProtection(name, 0);
1490 }
1491
1492 return DeleteFile(name);
1493 }
1494
1495
1496 BPTR OpenDestDir(STRPTR name, struct CopyData *cd)
1497 {
1498 LONG a, err = 0, cr = 0;
1499 BPTR dir;
1500 STRPTR ptr = name;
1501 UBYTE as;
1502
1503 if ((cd->Mode == COPYMODE_COPY || cd->Mode == COPYMODE_MOVE) && !TestFileSys(name, cd))
1504 {
1505 cd->Flags |= COPYFLAG_DESNOFILESYS;
1506 CopyMem(name, cd->DestName, 1 + strlen(name));
1507
1508 return Lock("", SHARED_LOCK);
1509 }
1510
1511 while (!err && *ptr != 0)
1512 {
1513 while (*ptr && *ptr != '/')
1514 {
1515 ++ptr;
1516 }
1517
1518 as = *ptr;
1519 *ptr = 0;
1520
1521 if ((a = TestDest(name, 1, cd)) == TESTDEST_CANTDELETE)
1522 {
1523 if (!(cd->Flags & COPYFLAG_QUIET))
1524 {
1525 PutStr(TEXT_ERR_DEST_DIR);
1526 }
1527
1528 err = 2;
1529 }
1530 else if (a < 0)
1531 {
1532 err = 1;
1533 }
1534 else if (a != TESTDEST_DIR_OK)
1535 {
1536 if ((dir = CreateDir(name)))
1537 {
1538 ++cr;
1539
1540 if ((cd->Flags & COPYFLAG_VERBOSE))
1541 {
1542 PrintName(name, 1, 1, 1, cd);
1543 Printf("%s\n", TEXT_CREATED);
1544 }
1545
1546 UnLock(dir);
1547 }
1548 else
1549 {
1550 cd->IoErr = IoErr();
1551 if (!(cd->Flags & COPYFLAG_QUIET))
1552 {
1553 PrintNotDone(name, TEXT_CREATED, 1, 1, cd);
1554 }
1555
1556 err = 2;
1557 }
1558 }
1559
1560 *ptr = as;
1561
1562 /* 26-Oct-2003 bugfix: Don't scan past end of the string.
1563 * as is the old char, if '\0' we've reached the end of the
1564 * string. - Piru
1565 */
1566 if (as)
1567 {
1568 ptr++;
1569 }
1570 }
1571
1572 if (err)
1573 {
1574 cd->RetVal = RETURN_ERROR;
1575
1576 if (!(cd->Flags & COPYFLAG_QUIET) && err == 1)
1577 {
1578 PrintNotDone(name, TEXT_OPENED_FOR_OUTPUT, 1, 1, cd);
1579 }
1580
1581 return 0;
1582 }
1583
1584 if (cd->Mode == COPYMODE_MAKEDIR && !cr && !(cd->Flags & COPYFLAG_QUIET))
1585 {
1586 cd->IoErr = ERROR_OBJECT_EXISTS;
1587 PrintNotDone(name, TEXT_CREATED, 1, 1, cd);
1588 }
1589
1590 return Lock(name, SHARED_LOCK);
1591 }
1592
1593
1594 void PrintName(CONST_STRPTR name, ULONG deep, ULONG dir, ULONG txt, struct CopyData *cd)
1595 {
1596 #if 0
1597 deep %= PRINTOUT_SPACES; /* reduce number of spaces */
1598 /* This produces an error with MaxonC++ */
1599 #endif
1600
1601 PutStr(" ");
1602 if (deep)
1603 {
1604 while (--deep)
1605 {
1606 PutStr(" ");
1607 }
1608 }
1609
1610 if (dir)
1611 {
1612 PutStr(" ");
1613 }
1614
1615 #if 0
1616 if ((deep = strlen(name)) > PRINTOUT_SIZE) /* reduce name size */
1617 {
1618 name += deep-PRINTOUT_SIZE;
1619 PutStr("...");
1620 }
1621 #endif
1622
1623 Printf((dir ? TEXT_DIRECTORY : (STRPTR) "%s"), name);
1624
1625 if (!dir && txt)
1626 {
1627 PutStr("..");
1628 }
1629
1630 Flush(Output());
1631 }
1632
1633
1634 void PrintNotDone(CONST_STRPTR name, CONST_STRPTR txt, ULONG deep, ULONG dir, struct CopyData *cd)
1635 {
1636 #if !USE_ALWAYSVERBOSE
1637 if (name)
1638 {
1639 PrintName(name, deep, dir, 1, cd);
1640 }
1641 #endif
1642
1643 Printf(TEXT_NOT_DONE, txt);
1644 if (cd->IoErr != 0)
1645 {
1646 PutStr(" - ");
1647 PrintFault(cd->IoErr, NULL);
1648 }
1649 else
1650 PutStr("\n");
1651 }
1652
1653
1654 /* returns value, when it seems to be a filesystem */
1655 ULONG TestFileSys(STRPTR name, struct CopyData *cd)
1656 {
1657 STRPTR n = name;
1658 ULONG ret = 1;
1659
1660 while (*n && *n != ':')
1661 {
1662 ++n;
1663 }
1664
1665 if (*(n++) == ':')
1666 {
1667 UBYTE a;
1668
1669 a = *n;
1670 *n = 0;
1671 ret = IsFileSystem(name);
1672 *n = a;
1673 }
1674
1675 return ret;
1676 }
1677
1678
1679 void DoWork(STRPTR name, struct CopyData *cd)
1680 {
1681 BPTR pdir, lock = 0;
1682 CONST_STRPTR printerr = NULL, printok = "";
1683
1684 #if DEBUG
1685 Printf("DoWork(%s, .)\n", name);
1686 #endif
1687
1688 if (cd->RetVal > (cd->Flags & COPYFLAG_ERRWARN ? RETURN_OK : RETURN_WARN) || cd->RetVal2)
1689 {
1690 #if DEBUG
1691 Printf("DoWork(RetVal %ld)\n", cd->RetVal);
1692 #endif
1693 return;
1694 }
1695
1696 if (cd->Mode != COPYMODE_DELETE && !(cd->Flags & COPYFLAG_DESNOFILESYS))
1697 {
1698 if (!cd->DestPathSize)
1699 {
1700 if (!NameFromLock(cd->CurDest, cd->DestName, FILEPATH_SIZE))
1701 {
1702 cd->RetVal2 = RETURN_FAIL;
1703
1704 #if DEBUG
1705 Printf("DoWork(NameFromLock RetVal %ld)\n", cd->RetVal);
1706 #endif
1707
1708 return;
1709 }
1710
1711 cd->DestPathSize = strlen(cd->DestName);
1712 }
1713
1714 cd->DestName[cd->DestPathSize] = 0;
1715 AddPart(cd->DestName, name, FILEPATH_SIZE);
1716 }
1717
1718 if (cd->Flags & (COPYFLAG_SRCNOFILESYS|COPYFLAG_DESNOFILESYS))
1719 {
1720 ULONG res = 0;
1721 BPTR in, out;
1722 CONST_STRPTR txt = TEXT_OPENED_FOR_OUTPUT;
1723
1724 #if DEBUG
1725 Printf("Partly DIRECT mode active now (%s - %s)\n", cd->FileName,
1726 cd->DestName);
1727 #endif
1728
1729 if ((in = Open(cd->FileName, MODE_OLDFILE)))
1730 {
1731 txt = cd->Mode == COPYMODE_MOVE ? TEXT_MOVED : TEXT_COPIED;
1732
1733 if ((out = Open(cd->DestName, MODE_NEWFILE)))
1734 {
1735 ULONG h;
1736
1737 h = CopyFile(in, out, cd->BufferSize, cd);
1738 if (h != 0)
1739 cd->IoErr = IoErr();
1740 Close(out);
1741 Close(in);
1742 in = BNULL;
1743
1744 if (!h)
1745 {
1746 if (cd->Mode == COPYMODE_MOVE)
1747 {
1748 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
1749 {
1750 res = 1;
1751 }
1752 }
1753 else
1754 {
1755 res = 1;
1756 }
1757 } else {
1758 KillFile(cd->DestName, 0, cd);
1759 }
1760 }
1761 else
1762 cd->IoErr = IoErr();
1763
1764 if (in != BNULL)
1765 Close(in);
1766 }
1767 else
1768 cd->IoErr = IoErr();
1769
1770 if (!res && !(cd->Flags & COPYFLAG_QUIET))
1771 {
1772 PrintNotDone(name, txt, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd);
1773 }
1774 else
1775 {
1776 cd->Flags |= COPYFLAG_DONE;
1777
1778 if ((cd->Flags & COPYFLAG_VERBOSE))
1779 {
1780 Printf("%s\n", txt);
1781 }
1782 }
1783
1784 #if DEBUG
1785 PutStr("DoWork(done)\n");
1786 #endif
1787 return;
1788 }
1789
1790 if (!(lock = Lock(cd->FileName, SHARED_LOCK)))
1791 {
1792 cd->RetVal = RETURN_WARN;
1793 cd->IoErr = IoErr();
1794
1795 if (!(cd->Flags & COPYFLAG_QUIET))
1796 {
1797 PrintNotDone(cd->Fib.fib_FileName, TEXT_READ, cd->Deep,
1798 cd->Fib.fib_DirEntryType > 0, cd);
1799 }
1800
1801 #if DEBUG
1802 Printf("DoWork(Lock RetVal %ld)\n", cd->RetVal);
1803 #endif
1804 return;
1805 }
1806
1807 if (!(pdir = ParentDir(lock)))
1808 {
1809 cd->RetVal = RETURN_ERROR;
1810
1811 if (cd->Mode == COPYMODE_DELETE)
1812 {
1813 if (!(cd->Flags & COPYFLAG_QUIET))
1814 {
1815 Printf(" %s ", cd->FileName);
1816 Printf(TEXT_NOT_DONE, TEXT_DELETED);
1817 Printf("%s\n", TEXT_ERR_DELETE_DEVICE);
1818 }
1819 }
1820
1821 UnLock(lock);
1822
1823 #if DEBUG
1824 Printf("DoWork(ParentDir %ld)\n", cd->RetVal);
1825 #endif
1826 return;
1827 }
1828
1829 UnLock(pdir);
1830
1831 if (!(cd->Flags & COPYFLAG_QUIET))
1832 {
1833 if ((cd->Flags & COPYFLAG_VERBOSE))
1834 {
1835 PrintName(name, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd->Fib.fib_DirEntryType < 0 ||
1836 (cd->Flags & COPYFLAG_ALL ? cd->Mode != COPYMODE_DELETE : cd->Mode != COPYMODE_COPY) ||
1837 cd->Flags & COPYFLAG_ENTERSECOND, cd);
1838 }
1839 }
1840
1841 if ((cd->Flags & COPYFLAG_ENTERSECOND) || (cd->Mode == COPYMODE_DELETE &&
1842 (!(cd->Flags & COPYFLAG_ALL) || cd->Fib.fib_DirEntryType < 0)))
1843 {
1844 UnLock(lock);
1845 lock = 0;
1846
1847 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
1848 {
1849 printok = TEXT_DELETED;
1850 }
1851 else
1852 {
1853 cd->RetVal = RETURN_WARN;
1854 printerr = TEXT_DELETED;
1855 }
1856 }
1857 else if (cd->Mode == COPYMODE_DELETE)
1858 {
1859 ;
1860 }
1861 else if (cd->Fib.fib_DirEntryType > 0)
1862 {
1863 LONG a;
1864
1865 if ((cd->Flags & COPYFLAG_ALL || cd->Mode == COPYMODE_LINK ||
1866 cd->Mode == COPYMODE_MOVE) && TestLoop(lock, cd->CurDest, cd))
1867 {
1868 printok = 0;
1869 cd->RetVal = RETURN_ERROR;
1870
1871 if (!(cd->Flags & COPYFLAG_QUIET))
1872 {
1873 if (!(cd->Flags & COPYFLAG_VERBOSE))
1874 {
1875 PrintName(name, cd->Deep, 1, 1, cd);
1876 }
1877
1878 Printf(TEXT_NOT_DONE, TEXT_ENTERED);
1879 PutStr(TEXT_ERR_INFINITE_LOOP);
1880 }
1881 }
1882 else if ((a = TestDest(cd->DestName, 1, cd)) < 0)
1883 {
1884 printerr = TEXT_CREATED;
1885 cd->RetVal = RETURN_ERROR;
1886 }
1887 else if (cd->Flags & COPYFLAG_ALL)
1888 {
1889 BPTR i;
1890
1891 i = cd->CurDest;
1892 cd->DestPathSize = 0;
1893
1894 if (a == TESTDEST_DIR_OK)
1895 {
1896 if (!(cd->CurDest = Lock(cd->DestName, SHARED_LOCK)))
1897 {
1898 cd->IoErr = IoErr();
1899 printerr = TEXT_ENTERED;
1900 cd->RetVal = RETURN_ERROR;
1901 }
1902 else
1903 {
1904 #if USE_ALWAYSVERBOSE
1905 printok = "";
1906 #else
1907 printok = TEXT_ENTERED;
1908 #endif
1909 }
1910 }
1911 else if ((cd->CurDest = CreateDir(cd->DestName)))
1912 {
1913 UnLock(cd->CurDest);
1914
1915 if ((cd->CurDest = Lock(cd->DestName, SHARED_LOCK)))
1916 {
1917 printok = TEXT_CREATED;
1918 }
1919 else
1920 {
1921 cd->IoErr = IoErr();
1922 printerr = TEXT_ENTERED;
1923 cd->RetVal = RETURN_ERROR;
1924 }
1925 }
1926 else
1927 {
1928 cd->IoErr = IoErr();
1929 printerr = TEXT_CREATED;
1930 cd->RetVal = RETURN_ERROR;
1931 }
1932
1933 if (!cd->CurDest)
1934 {
1935 cd->CurDest = i;
1936 }
1937 else if (i != cd->Destination)
1938 {
1939 UnLock(i);
1940 }
1941 }
1942 else if (cd->Mode == COPYMODE_MOVE)
1943 {
1944 if (Rename(cd->FileName, cd->DestName))
1945 {
1946 printok = TEXT_RENAMED;
1947 }
1948 else
1949 {
1950 cd->IoErr = IoErr();
1951 printerr = TEXT_RENAMED;
1952 cd->RetVal = RETURN_WARN;
1953 }
1954 }
1955 else if (cd->Mode == COPYMODE_LINK)
1956 {
1957 if (!(cd->Flags & COPYFLAG_FORCELINK))
1958 {
1959 printok = 0;
1960 cd->RetVal = RETURN_WARN;
1961
1962 if (!(cd->Flags & COPYFLAG_QUIET))
1963 {
1964 if (!(cd->Flags & COPYFLAG_VERBOSE))
1965 {
1966 PrintName(name, cd->Deep, 1, 1, cd);
1967 }
1968
1969 Printf(TEXT_NOT_DONE, TEXT_LINKED);
1970 PutStr(TEXT_ERR_FORCELINK);
1971 }
1972 }
1973 else if (LinkFile(lock, cd->DestName, cd->Flags & COPYFLAG_SOFTLINK, cd))
1974 {
1975 printok = TEXT_LINKED;
1976 }
1977 else
1978 {
1979 printerr = TEXT_LINKED;
1980 cd->RetVal = RETURN_WARN;
1981 }
1982 }
1983 else /* COPY mode only displays directories, when not ALL */
1984 {
1985 printok = 0;
1986
1987 if (!(cd->Flags & COPYFLAG_QUIET))
1988 {
1989 if (cd->Flags & COPYFLAG_VERBOSE)
1990 {
1991 PutStr("\n");
1992 }
1993 }
1994 }
1995 }
1996 else
1997 {
1998 /* test for existing destination file */
1999 if (TestDest(cd->DestName, 0, cd) < 0)
2000 {
2001 printerr = TEXT_OPENED_FOR_OUTPUT;
2002 }
2003 else if (cd->Mode == COPYMODE_MOVE && Rename(cd->FileName, cd->DestName))
2004 {
2005 printok = TEXT_RENAMED;
2006 }
2007 else if (cd->Mode == COPYMODE_LINK)
2008 {
2009 if (!(cd->Flags & COPYFLAG_SOFTLINK) && LinkFile(lock, cd->DestName, 0, cd))
2010 {
2011 printok = TEXT_LINKED;
2012 }
2013 else
2014 {
2015 printerr = TEXT_LINKED;
2016 cd->RetVal = RETURN_WARN;
2017
2018 if (cd->Flags & COPYFLAG_SOFTLINK)
2019 {
2020 cd->IoErr = ERROR_OBJECT_WRONG_TYPE;
2021 }
2022 }
2023 }
2024 else
2025 {
2026 ULONG res = 0, h;
2027 BPTR in, out;
2028 CONST_STRPTR txt = TEXT_OPENED_FOR_OUTPUT;
2029
2030 if ((out = Open(cd->DestName, MODE_NEWFILE)))
2031 {
2032 ULONG kill = 1;
2033
2034 txt = cd->Mode == COPYMODE_MOVE ? TEXT_MOVED : TEXT_COPIED;
2035 UnLock(lock);
2036 lock = 0;
2037
2038 if ((in = Open(cd->FileName, MODE_OLDFILE)))
2039 {
2040 h = CopyFile(in, out, cd->BufferSize, cd);
2041 if (h != 0)
2042 cd->IoErr = IoErr();
2043 Close(out);
2044 out = BNULL;
2045 Close(in);
2046
2047 if (!h)
2048 {
2049 kill = 0;
2050
2051 if (cd->Mode == COPYMODE_MOVE)
2052 {
2053 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
2054 {
2055 res = 1;
2056 }
2057 }
2058 else
2059 {
2060 res = 1;
2061 }
2062 }
2063 }
2064 else cd->IoErr = IoErr();
2065
2066 if (out)
2067 {
2068 Close(out);
2069 }
2070
2071 if (kill)
2072 {
2073 KillFile(cd->DestName, 0, cd);
2074 }
2075 }
2076 else cd->IoErr = IoErr();
2077
2078 if (!res)
2079 {
2080 printerr = txt;
2081 cd->RetVal = RETURN_WARN;
2082 }
2083 else
2084 {
2085 printok = txt;
2086 }
2087 }
2088 }
2089
2090 if (printerr && !(cd->Flags & COPYFLAG_QUIET))
2091 {
2092 PrintNotDone(name, printerr, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd);
2093 }
2094 else if (printok)
2095 {
2096 cd->Flags |= COPYFLAG_DONE;
2097
2098 if (!(cd->Flags & COPYFLAG_QUIET))
2099 {
2100 if ((cd->Flags & COPYFLAG_VERBOSE))
2101 {
2102 Printf("%s\n", printok);
2103 }
2104 }
2105
2106 SetData(cd->DestName, cd);
2107 }
2108
2109 if (lock)
2110 {
2111 UnLock(lock);
2112 }
2113 }
2114
2115
2116 LONG CopyFile(BPTR from, BPTR to, ULONG bufsize, struct CopyData *cd)
2117 {
2118 STRPTR buffer;
2119 LONG s, err = 0;
2120
2121 if (cd->CopyBuf)
2122 {
2123 buffer = cd->CopyBuf;
2124 bufsize = cd->CopyBufLen;
2125 }
2126 else
2127 {
2128 do
2129 {
2130 buffer = (STRPTR)AllocMem(bufsize, MEMF_PUBLIC);
2131 if (buffer)
2132 {
2133 cd->CopyBuf = buffer;
2134 cd->CopyBufLen = bufsize;
2135 break;
2136 }
2137
2138 bufsize >>= 1;
2139
2140 } while (bufsize >= 512);
2141 }
2142
2143 if (buffer)
2144 {
2145 #if USE_BOGUSEOFWORKAROUND
2146 struct FileInfoBlock *fib = (struct FileInfoBlock *) buffer; /* NOTE: bufsize is min 512 bytes */
2147
2148 if (ExamineFH(from, fib))
2149 {
2150 #warning "****** WARNING: No largefile support! ******"
2151 ULONG filesize = fib->fib_Size, copied = 0;
2152
2153 /*Printf("filesize: %lu\n", filesize);*/
2154
2155 do
2156 {
2157 ULONG brk = CTRL_C;
2158 if (brk || (s = Read(from, buffer, bufsize)) == -1 || Write(to, buffer, s) != s)
2159 {
2160 if (brk)
2161 {
2162 cd->IoErr = ERROR_BREAK;
2163 }
2164 err = RETURN_FAIL;
2165 break;
2166 }
2167 else if (s == 0 && copied < filesize)
2168 {
2169 /* premature EOF with buggy fs */
2170 err = RETURN_FAIL;
2171 break;
2172 }
2173
2174 copied += s;
2175
2176 } while (copied < filesize);
2177
2178 /*{ LONG ioerr = IoErr();
2179 Printf("copied %lu/%lu\n", copied, filesize);
2180 SetIoErr(ioerr);}*/
2181 }
2182 else
2183 #endif /* USE_BOGUSEOFWORKAROUND */
2184 {
2185 /* Stream or so, copy until EOF or error */
2186 do
2187 {
2188 ULONG brk = CTRL_C;
2189 /* AROS: This flush appears to be required if reading from '*'
2190 * Maybe a bug in Read(), or AROS buffering?
2191 */
2192 Flush(from);
2193 if (brk || (s = Read(from, buffer, bufsize)) == -1 || Write(to, buffer, s) != s)
2194 {
2195 if (brk)
2196 {
2197 cd->IoErr = ERROR_BREAK;
2198 }
2199 err = RETURN_FAIL;
2200 break;
2201 }
2202 } while (s > 0);
2203 }
2204
2205 /* Freed at exit to avoid fragmentation */
2206 /*FreeMem(buffer, bufsize);*/
2207 }
2208 else
2209 {
2210 err = RETURN_FAIL;
2211 }
2212
2213 return err;
2214 }
2215
2216
2217 /* Softlink's path starts always with device name! f.e. "Ram Disk:T/..." */
2218 LONG LinkFile(BPTR from, STRPTR to, ULONG soft, struct CopyData *cd)
2219 {
2220 if (soft)
2221 {
2222 LONG ret = FALSE;
2223 UBYTE *name;
2224
2225 name = AllocMem(FILEPATH_SIZE, MEMF_ANY);
2226 if (name)
2227 {
2228 if (NameFromLock(from, name, FILEPATH_SIZE))
2229 {
2230 ret = MakeLink(to, name, LINK_SOFT);
2231 }
2232
2233 FreeMem(name, FILEPATH_SIZE);
2234 }
2235
2236 return ret;
2237 }
2238 else
2239 {
2240 return MakeLink(to, (void *)from, LINK_HARD);
2241 }
2242 }
2243
2244
2245 /* return 0 means no loop, return != 0 means loop found */
2246 ULONG TestLoop(BPTR srcdir, BPTR destdir, struct CopyData *cd)
2247 {
2248 ULONG loop = 0;
2249 BPTR par, lock;
2250
2251 lock = destdir;
2252
2253 if (SameDevice(srcdir, destdir))
2254 {
2255 do
2256 {
2257 if (!SameLock(srcdir, lock))
2258 {
2259 loop = 1;
2260 }
2261 else
2262 {
2263 par = ParentDir(lock);
2264
2265 if (lock != destdir)
2266 {
2267 UnLock(lock);
2268 }
2269
2270 lock = par;
2271 }
2272 }
2273 while(!loop && lock);
2274 }
2275
2276 if (lock != destdir)
2277 {
2278 UnLock(lock);
2279 }
2280
2281 return loop;
2282 }
2283
2284
2285 void SetData(STRPTR name, struct CopyData *cd)
2286 {
2287 if (cd->Flags & COPYFLAG_NOPRO)
2288 {
2289 /* Is already set! - Piru */
2290 //SetProtection(name, 0);
2291 }
2292 else
2293 {
2294 SetProtection(name, cd->Fib.fib_Protection & (ULONG) ~FIBF_ARCHIVE);
2295 }
2296
2297 if (cd->Flags & COPYFLAG_DATES)
2298 {
2299 SetFileDate(name, &cd->Fib.fib_Date);
2300 }
2301
2302 if (cd->Flags & COPYFLAG_COMMENT)
2303 {
2304 SetComment(name, cd->Fib.fib_Comment);
2305 }
2306 }
2307
2308
2309 LONG TestDest(STRPTR name, ULONG type, struct CopyData *cd)
2310 {
2311 LONG ret = TESTDEST_ERROR;
2312 BPTR lock;
2313
2314 if ((lock = Lock(name, SHARED_LOCK)))
2315 {
2316 struct FileInfoBlock *fib;
2317
2318 if ((fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
2319 {
2320 if (Examine(lock, fib))
2321 {
2322 UnLock(lock);
2323 lock = 0;
2324
2325 if (type)
2326 {
2327 if (fib->fib_DirEntryType > 0)
2328 {
2329 ret = TESTDEST_DIR_OK;
2330 }
2331 else if (!(cd->Flags & COPYFLAG_DONTOVERWRITE))
2332 {
2333 if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2334 {
2335 ret = TESTDEST_DELETED;
2336 }
2337 }
2338 else
2339 {
2340 ret = TESTDEST_CANTDELETE;
2341 }
2342 }
2343 else if (cd->Flags & COPYFLAG_DONTOVERWRITE)
2344 {
2345 if (cd->Flags & COPYFLAG_NEWER)
2346 {
2347 if( CheckVersion( cd ) == CHECKVER_DESTOLDER )
2348 {
2349 if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2350 {
2351 ret = TESTDEST_DELETED;
2352 }
2353 }
2354 else
2355 {
2356 ret = TESTDEST_CANTDELETE;
2357 }
2358 }
2359 else /* normal "dont overwrite mode" */
2360 {
2361 ret = TESTDEST_CANTDELETE;
2362 }
2363 }
2364 else if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2365 {
2366 ret = TESTDEST_DELETED;
2367 }
2368 }
2369
2370 FreeDosObject(DOS_FIB, fib);
2371 }
2372
2373 if (lock)
2374 {
2375 UnLock(lock);
2376 }
2377 }
2378 else
2379 {
2380 ret = TESTDEST_NONE;
2381 }
2382
2383 if (ret == TESTDEST_CANTDELETE)
2384 {
2385 cd->IoErr = ERROR_OBJECT_EXISTS;
2386 }
2387 else if (ret == TESTDEST_ERROR)
2388 {
2389 cd->IoErr = IoErr();
2390 }
2391
2392 return ret;
2393 }
2394
2395 /*
2396 ** We compare current file versions and return the result
2397 ** see CHECKVER_#? values
2398 */
2399
2400 static LONG CheckVersion( struct CopyData *cd )
2401 {
2402 struct VersionData vds;
2403 struct VersionData vdd;
2404 LONG resversion = CHECKVER_EQUAL;
2405 LONG resdate = CHECKVER_EQUAL;
2406
2407 if( VersionFind( cd->FileName, &vds, cd ) )
2408 {
2409 if( VersionFind( cd->DestName, &vdd, cd ) )
2410 {
2411 /* version and revision must be available to ensure a proper operation */
2412 if( ((vdd.vd_Version != -1) && (vds.vd_Version != -1) && (vdd.vd_Revision != -1) && (vds.vd_Revision != -1)) )
2413 {
2414 /* first we make the stuff comparable. If one component is missing we reset both */
2415 if( vdd.vd_Year == -1 || vds.vd_Year == -1 )
2416 {
2417 vdd.vd_Year = 0;
2418 vds.vd_Year = 0;
2419 }
2420 if( vdd.vd_Month == -1 || vds.vd_Month == -1 )
2421 {
2422 vdd.vd_Month = 0;
2423 vds.vd_Month = 0;
2424 }
2425 if( vdd.vd_Day == -1 || vds.vd_Day == -1 )
2426 {
2427 vdd.vd_Day = 0;
2428 vds.vd_Day = 0;
2429 }
2430
2431 /* check version */
2432 resversion = CHECKVER_DESTOLDER;
2433 if( ((vdd.vd_Version == vds.vd_Version) && vdd.vd_Revision == vds.vd_Revision ) )
2434 {
2435 resversion = CHECKVER_EQUAL;
2436 }
2437 else if( (vdd.vd_Version > vds.vd_Version) ||
2438 ((vdd.vd_Version == vds.vd_Version) && vdd.vd_Revision > vds.vd_Revision ) )
2439 {
2440 resversion = CHECKVER_DESTNEWER;
2441 }
2442 /* check date */
2443
2444 resdate = CHECKVER_DESTOLDER;
2445 if( ((vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month == vds.vd_Month) && (vdd.vd_Day == vds.vd_Day) ) )
2446 {
2447 resdate = CHECKVER_EQUAL;
2448 }
2449 else
2450 {
2451 if( ( (vdd.vd_Year > vds.vd_Year ) ||
2452 ( (vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month > vds.vd_Month ) ) ||
2453 ( (vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month == vds.vd_Month ) && (vdd.vd_Day > vds.vd_Day ) ) ))
2454 {
2455 resdate = CHECKVER_DESTNEWER;
2456 }
2457 }
2458
2459 /* plausible check */
2460 if( ((resversion == CHECKVER_DESTNEWER) && (resdate == CHECKVER_DESTOLDER)) || /* newer version with older date */
2461 ((resversion == CHECKVER_DESTOLDER) && (resdate == CHECKVER_DESTNEWER)) ) /* older version with newer date */
2462 {
2463 /* we maybe should inform the user about this */
2464 return( CHECKVER_EQUAL );
2465 }
2466 }
2467 }
2468 }
2469 /* compose result */
2470
2471 if( (resversion == resdate) || (resversion == CHECKVER_EQUAL) )
2472 {
2473 return( resdate );
2474 }
2475 else
2476 {
2477 return( resversion );
2478 }
2479 }
2480
2481
2482
2483 /*
2484 ** Searches the given file for a version string and fills version data struct with the result.
2485 ** Returns false if no version was found. Returns true if the version got parsed and version data
2486 ** is valid.
2487 */
2488
2489 #define VERSBUFFERSIZE 4096 /* must be as big as the biggest version string we want to handle. */
2490
2491 static BOOL VersionFind( CONST_STRPTR path, struct VersionData *vds, struct CopyData *cd)
2492 {
2493 BPTR handle;
2494 STRPTR buf;
2495 ULONG i, rc;
2496
2497 rc = FALSE;
2498
2499 if ( (buf = AllocVec(VERSBUFFERSIZE, MEMF_PUBLIC | MEMF_CLEAR)) )
2500 {
2501 if ( (handle = Open(path, MODE_OLDFILE)) )
2502 {
2503 long index = 0;
2504
2505 while( ( (index += Read(handle, &buf[index], VERSBUFFERSIZE-index)) > 5) && !rc )
2506 {
2507 for (i = 0; i < index-5; i++) {
2508 if( buf[i] == '$' && buf[i+1] == 'V' && buf[i+2] == 'E' && buf[i+3] == 'R' && buf[i+4] == ':' ) {
2509 CopyMem( &buf[i], buf, index-i );
2510 index -= i;
2511 (index += Read(handle, &buf[index], VERSBUFFERSIZE-index));
2512 /* now the version string is aligned and complete in buffer */
2513 makeversionfromstring( buf, vds, cd );
2514 rc = TRUE;
2515 break;
2516 }
2517 }
2518 CopyMem( &buf[index-5], &buf[0], 5 );
2519 index = 5;
2520 }
2521 Close(handle);
2522 }
2523 FreeVec(buf);
2524 }
2525 return (rc);
2526 }
2527
2528
2529 /*
2530 ** This function extracts the version information from a given version string.
2531 ** the result will be store in the given version data structure.
2532 **
2533 ** NOTE: There is no need to preset the version data struct. All fields will
2534 ** be reset to defaults, so in case of a faulty version string the result data
2535 ** will be checkable.
2536 */
2537
2538 static
2539 void makeversionfromstring( STRPTR buffer, struct VersionData *vd, struct CopyData *cd)
2540 {
2541 LONG pos;
2542 ULONG tmp;
2543 STRPTR name;
2544
2545 /* reset data field */
2546
2547 vd->vd_Name[0] = '\0';
2548 vd->vd_Version = -1;
2549 vd->vd_Revision = -1;
2550 vd->vd_Day = -1;
2551 vd->vd_Month = -1;
2552 vd->vd_Year = -1;
2553
2554 buffer = skipspaces( buffer ); /* skip before $VER: */
2555 buffer = skipnonspaces( buffer ); /* skip $VER: */
2556 buffer = skipspaces( buffer ); /* skip spaces before tool name */
2557 name = buffer;
2558 buffer = skipnonspaces( buffer ); /* skip name of tool */
2559
2560 if( (tmp = ((long) buffer - (long) name) ) && *buffer )
2561 {
2562 CopyMem( name, vd->vd_Name, MIN( tmp, VDNAMESIZE-1) );
2563 vd->vd_Name[MIN( tmp, VDNAMESIZE-1)] = '\0'; /* terminate name string inside target buffer */
2564
2565 buffer = skipspaces( buffer ); /* skip spaces before version */
2566 if( *buffer ) {
2567
2568 /* Do version */
2569
2570 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2571 {
2572 vd->vd_Version = tmp;
2573
2574 /* Do revision */
2575
2576 buffer += pos;
2577 buffer = skipspaces(buffer);
2578 if (*buffer++ == '.')
2579 {
2580 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2581 {
2582 vd->vd_Revision = tmp;
2583 buffer += pos;
2584 buffer = skipspaces(buffer);
2585 if (*buffer++ == '(')
2586 {
2587 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2588 {
2589 vd->vd_Day = tmp;
2590 buffer += pos;
2591 if (*buffer++ == '.')
2592 {
2593 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2594 {
2595 vd->vd_Month = tmp;
2596 buffer += pos;
2597 if (*buffer++ == '.')
2598 {
2599 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2600 {
2601 if( (tmp >= 70) && (tmp <= 99) )
2602 {
2603 tmp += 1900;
2604 }
2605 if( (tmp < 70) )
2606 {
2607 tmp += 2000;
2608 }
2609 vd->vd_Year = tmp;
2610 }
2611 }
2612 }
2613 }
2614 }
2615 }
2616 }
2617 }
2618 }
2619 }
2620 }
2621 }
2622
2623 /* Return a pointer to a string, stripped by all leading space characters
2624 * (SPACE).
2625 */
2626 static
2627 STRPTR skipspaces( STRPTR buffer)
2628 {
2629 for (;; buffer++)
2630 {
2631 if (buffer[0] == '\0' || buffer[0] != ' ')
2632 {
2633 return( buffer );
2634 }
2635 }
2636 }
2637
2638 /* Return a pointer to a string, stripped by all non space characters
2639 * (SPACE).
2640 */
2641 static
2642 STRPTR skipnonspaces( STRPTR buffer)
2643 {
2644 for (;; buffer++)
2645 {
2646 if (buffer[0] == '\0' || buffer[0] == ' ')
2647 {
2648 return( buffer );
2649 }
2650 }
2651 }
2652
2653
Mirror of AROS' svn.