?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add task.resource to aros.elf as well
[AROS.git] / workbench / c / Copy.c
blob212d8ea7a581f06ae94e1363866a54892a6f6f7f
1 /*
2 Copyright © 2001-2017, 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 #ifdef __MORPHOS__
551 #define BNULL NULL
552 int main()
553 {
554 #else
555 __startup static AROS_PROCH(Start, argstr, argsize, SysBase)
556 #endif
557 {
558 AROS_PROCFUNC_INIT
559
560 struct DosLibrary *DOSBase;
561 struct Process *task;
562 struct CopyData *cd;
563 int retval = RETURN_FAIL;
564
565 /* test for WB and reply startup-message */
566 if (!(task = (struct Process *)FindTask(NULL))->pr_CLI)
567 {
568 WaitPort(&task->pr_MsgPort);
569 Forbid();
570 ReplyMsg(GetMsg(&task->pr_MsgPort));
571
572 return RETURN_FAIL;
573 }
574
575 DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37);
576 cd = AllocMem(sizeof(*cd), MEMF_PUBLIC | MEMF_CLEAR);
577
578 if (DOSBase && cd)
579 {
580 STRPTR a[2] = { "", 0 };
581 struct RDArgs *rda;
582 struct IptrArgs iArgs;
583 struct Args args = {};
584
585 cd->SysBase = SysBase;
586 cd->DOSBase = DOSBase;
587 #define SysBase cd->SysBase
588 #define DOSBase cd->DOSBase
589
590 cd->BufferSize = 512*1024;
591 cd->Mode = COPYMODE_COPY;
592 cd->RetVal2 = RETURN_FAIL;
593 cd->Deep = 1;
594
595 memset(&iArgs, 0, sizeof(struct IptrArgs));
596
597 rda = (struct RDArgs *)AllocDosObject(DOS_RDARGS, NULL);
598 if (rda)
599 {
600 rda->RDA_ExtHelp =
601 "FROM multiple input files\n"
602 "TO destination file or directory\n"
603 "PATTERN a pattern the filenames must match\n"
604 "BUFFER buffersize for copy buffer (default 200 [100K])\n"
605 "ALL deep scan into sub directories\n"
606 "DIRECT copy/delete only: work without any tests or options\n"
607 "CLONE copy comment, protection bits and date as well\n"
608 "DATES copy dates\n"
609 "NOPRO do not copy protection bits\n"
610 "COMMENT copy filecomment\n"
611 "QUIET suppress all output and requesters\n"
612 #if !USE_ALWAYSVERBOSE
613 "VERBOSE give additional output\n"
614 #endif
615 "NOREQ suppress requesters\n"
616 "ERRWARN do not proceed, when one file failed\n"
617 "MAKEDIR produce directories\n"
618 "MOVE delete source files after copying successful\n"
619 "DELETE do not copy, but delete the source files\n"
620 "HARDLINK make a hardlink to source instead of copying\n"
621 "SOFTLINK make a softlink to source instead of copying\n"
622 "FOLNK also makes links to directories\n"
623 "FODEL delete protected files also\n"
624 "FOOVR also overwrite protected files\n"
625 "DONTOVR do never overwrite destination\n"
626 "FORCE DO NOT USE. Call compatibility only.\n"
627 "NEWER will compare version strings and only overwrites older files\n";
628
629 if (ReadArgs(PARAM, (IPTR *)&iArgs, rda))
630 {
631 ULONG patbufsize = 0;
632 LONG i = 0;
633 APTR win = task->pr_WindowPtr;
634
635 args.from = (STRPTR *)iArgs.from;
636 args.to = (STRPTR)iArgs.to;
637 args.pattern = (STRPTR)iArgs.pattern;
638 args.buffer = (LONG *)iArgs.buffer;
639 args.all = (LONG)iArgs.all;
640 args.direct = (LONG)iArgs.direct;
641 args.clone = (LONG)iArgs.clone;
642 args.dates = (LONG)iArgs.dates;
643 args.nopro = (LONG)iArgs.nopro;
644 args.comment = (LONG)iArgs.comment;
645 args.quiet = (LONG)iArgs.quiet;
646 #if USE_ALWAYSVERBOSE
647 args.verbose = FALSE;
648 #else
649 args.verbose = (LONG)iArgs.verbose;
650 #endif
651 args.noreq = (LONG)iArgs.noreq;
652 args.errwarn = (LONG)iArgs.errwarn;
653 args.makedir = (LONG)iArgs.makedir;
654 args.move_mode = (LONG)iArgs.move_mode;
655 args.delete_mode = (LONG)iArgs.delete_mode;
656 args.hardlink = (LONG)iArgs.hardlink;
657 args.softlink = (LONG)iArgs.softlink;
658 args.forcelink = (LONG)iArgs.forcelink;
659 args.forcedelete = (LONG)iArgs.forcedelete;
660 args.forceoverwrite = (LONG)iArgs.forceoverwrite;
661 args.dontoverwrite = (LONG)iArgs.dontoverwrite;
662 args.force = (LONG)iArgs.force;
663 args.newer = (LONG)iArgs.newer;
664
665 if (args.quiet) /* when QUIET, SILENT and NOREQ are also
666 true! */
667 {
668 /* Original doesn't hide requesters with QUIET */
669 /*args.noreq = 1;*/
670 args.verbose = FALSE;
671 }
672
673 if (args.buffer && *args.buffer > 0) /* minimum buffer size */
674 {
675 cd->BufferSize = *args.buffer * 512;
676 }
677
678 if (args.quiet)
679 {
680 cd->Flags |= COPYFLAG_QUIET;
681 }
682
683 #if !USE_ALWAYSVERBOSE
684 if (args.verbose)
685 {
686 cd->Flags |= COPYFLAG_VERBOSE;
687 }
688 #endif
689 if (args.all)
690 {
691 cd->Flags |= COPYFLAG_ALL;
692 }
693
694 if (args.clone)
695 {
696 cd->Flags |= COPYFLAG_DATES | COPYFLAG_COMMENT;
697 }
698
699 if (args.dates)
700 {
701 cd->Flags |= COPYFLAG_DATES;
702 }
703
704 if (args.comment)
705 {
706 cd->Flags |= COPYFLAG_COMMENT;
707 }
708
709 if (args.nopro)
710 {
711 cd->Flags |= COPYFLAG_NOPRO;
712 }
713
714 if (args.forcelink)
715 {
716 cd->Flags |= COPYFLAG_FORCELINK;
717 }
718
719 if (args.forcedelete)
720 {
721 cd->Flags |= COPYFLAG_FORCEDELETE;
722 }
723
724 if (args.forceoverwrite)
725 {
726 cd->Flags |= COPYFLAG_FORCEOVERWRITE;
727 }
728
729 if (args.dontoverwrite)
730 {
731 cd->Flags |= COPYFLAG_DONTOVERWRITE;
732 }
733
734 if (args.newer)
735 {
736 cd->Flags |= COPYFLAG_NEWER|COPYFLAG_DONTOVERWRITE;
737 }
738
739 if (args.errwarn)
740 {
741 cd->Flags |= COPYFLAG_ERRWARN;
742 }
743
744 if (args.force) /* support OS Delete and MakeLink command
745 options */
746 {
747 if (args.delete_mode)
748 {
749 cd->Flags |= COPYFLAG_FORCEDELETE;
750 }
751
752 if (args.hardlink || args.softlink)
753 {
754 cd->Flags |= COPYFLAG_FORCELINK;
755 }
756 }
757
758 if (!args.from) /* no args.from means currentdir */
759 {
760 args.from = a;
761 }
762
763 if (args.noreq) /* no dos.library requests allowed */
764 {
765 task->pr_WindowPtr = (APTR)-1;
766 }
767
768 if (args.delete_mode)
769 {
770 ++i;
771 cd->Mode = COPYMODE_DELETE;
772 }
773
774 if (args.move_mode)
775 {
776 ++i;
777 cd->Mode = COPYMODE_MOVE;
778 }
779
780 if (args.makedir)
781 {
782 ++i;
783 cd->Mode = COPYMODE_MAKEDIR;
784 }
785
786 if (args.hardlink)
787 {
788 ++i;
789 cd->Mode = COPYMODE_LINK;
790 }
791
792 if (args.softlink)
793 {
794 ++i;
795 cd->Mode = COPYMODE_LINK;
796 cd->Flags |= COPYFLAG_SOFTLINK | COPYFLAG_FORCELINK;
797 }
798
799 if (cd->Mode != COPYMODE_DELETE &&
800 cd->Mode != COPYMODE_MAKEDIR && !args.to)
801 {
802 if (*(args.from + 1)) /* when no TO is specified, the arg
803 is last */
804 { /* one of from. Copy this argument into */
805 STRPTR *a; /* args.to */
806
807 a = args.from;
808
809 while(*(++a))
810 ;
811
812 args.to = *(--a);
813 *a = 0;
814 }
815 }
816 #if USE_ALWAYSVERBOSE
817
818 /* Only do this if quiet isn't set - bigfoot */
819 if (!args.quiet)
820 {
821 /* If more than two args, be verbose... - Piru */
822 if (args.from[0] && args.from[1])
823 {
824 args.verbose = TRUE;
825 cd->Flags |= COPYFLAG_VERBOSE;
826 }
827
828 /* If any of the sources is a pattern, be verbose... - Piru */
829 {
830 STRPTR *a;
831
832 for (a = args.from; *a; a++)
833 {
834 if (IsMatchPattern(*a, cd) != 0)
835 {
836 args.verbose = TRUE;
837 cd->Flags |= COPYFLAG_VERBOSE;
838 }
839 }
840 }
841 }
842 #endif
843
844 /* test if more than one of the above four or any other wrong
845 arguments */
846
847 if (i > 1 ||
848 (args.from == a && cd->Mode == COPYMODE_MAKEDIR) ||
849 (args.direct && (args.from == a || !*args.from ||
850 args.pattern ||
851 (cd->Flags & ~(COPYFLAG_QUIET | COPYFLAG_VERBOSE | COPYFLAG_ERRWARN)) ||
852 (cd->Mode != COPYMODE_DELETE && (cd->Mode != COPYMODE_COPY ||
853 !args.to || args.from[1])))) ||
854 (args.dontoverwrite && args.forceoverwrite) ||
855 /* (args.nopro && args.clone) ||*/ /* Ignore, like original - Piru */
856 (args.softlink && args.all) ||
857 (!args.to && cd->Mode != COPYMODE_DELETE && cd->Mode != COPYMODE_MAKEDIR))
858 {
859 cd->IoErr = ERROR_TOO_MANY_ARGS;
860 }
861 else if (cd->Mode == COPYMODE_MAKEDIR)
862 {
863 LONG i;
864 BPTR dir;
865 cd->RetVal2 = RETURN_OK;
866
867 #if !USE_ALWAYSVERBOSE
868 if (args.verbose)
869 {
870 PutStr(texts[TEXTNUM_MODE + COPYMODE_MAKEDIR]);
871 }
872 #endif
873
874 while (!cd->RetVal && !cd->RetVal2 && *args.from)
875 {
876 if ((i = IsPattern(*args.from, cd)))
877 {
878 if (i != -1)
879 {
880 cd->RetVal = RETURN_ERROR;
881
882 if (!args.quiet)
883 {
884 PutStr(TEXT_ERR_WILDCARD_DEST);
885 }
886 }
887 else
888 {
889 cd->RetVal2 = RETURN_FAIL;
890 }
891 }
892
893 if ((dir = OpenDestDir(*args.from, cd)))
894 {
895 UnLock(dir);
896 cd->Flags |= COPYFLAG_DONE;
897 }
898
899 ++args.from;
900 }
901 } /* cd->Mode == COPYMODE_MAKEDIR */
902 else if (args.direct)
903 {
904 if (cd->Mode == COPYMODE_COPY)
905 {
906 BPTR in, out;
907
908 if ((in = Open(*args.from, MODE_OLDFILE)))
909 {
910 if ((out = Open(args.to, MODE_NEWFILE)))
911 {
912 cd->RetVal2 = CopyFile(in, out, cd->BufferSize, cd);
913 if (cd->RetVal2 != 0)
914 cd->IoErr = IoErr();
915 Close(out);
916 }
917 else
918 cd->IoErr = IoErr();
919
920 Close(in);
921 }
922 else
923 cd->IoErr = IoErr();
924 }
925 else /* COPYMODE_DELETE */
926 {
927 while (*args.from)
928 {
929 KillFile(*(args.from++), cd->Flags & COPYFLAG_FORCEDELETE, cd);
930 }
931
932 cd->RetVal2 = RETURN_OK;
933 }
934 }
935 else
936 {
937 if (args.pattern && *args.pattern)
938 {
939 patbufsize = (strlen(args.pattern) << 1) + 3;
940
941 if ((cd->Pattern = (STRPTR)AllocMem(patbufsize,
942 MEMF_ANY)))
943 {
944 if (ParsePatternNoCase(args.pattern, cd->Pattern,
945 patbufsize) < 0)
946 {
947 FreeMem(cd->Pattern, patbufsize);
948 cd->Pattern = 0;
949 }
950 }
951 }
952
953 if (1) // (cd->Fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
954 {
955 #if !USE_ALWAYSVERBOSE
956 if (args.verbose)
957 {
958 PutStr(texts[TEXTNUM_MODE + cd->Mode +
959 (cd->Flags & COPYFLAG_SOFTLINK ? 1 : 0)]);
960 }
961 #endif
962 if (args.pattern && !cd->Pattern)
963 {
964 if (!*args.pattern)
965 {
966 cd->IoErr = ERROR_BAD_TEMPLATE;
967 }
968 }
969 else if (cd->Mode == COPYMODE_DELETE)
970 {
971 cd->RetVal2 = RETURN_OK;
972
973 while (cd->RetVal <= (args.errwarn ? RETURN_OK : RETURN_WARN)
974 && *args.from)
975 {
976 PatCopy(*(args.from++), cd);
977 }
978 }
979 else if ((i = IsPattern(args.to, cd)))
980 {
981 if (i != -1)
982 {
983 cd->RetVal = RETURN_ERROR;
984
985 if (!args.quiet)
986 {
987 PutStr(TEXT_ERR_WILDCARD_DEST);
988 }
989 }
990 }
991 else
992 {
993 STRPTR path;
994
995 if (*(path = PathPart(args.to)) == '/')
996 {
997 ++path; /* is destination a path description ? */
998 }
999
1000 if (*path && !*(args.from+1) &&
1001 !(i = IsMatchPattern(*args.from, cd)))
1002 {
1003 BPTR lock;
1004
1005 /* is destination an existing directory */
1006 if ((lock = Lock(args.to, SHARED_LOCK)))
1007 {
1008 if (Examine(lock, &cd->Fib))
1009 {
1010 if (cd->Fib.fib_DirEntryType > 0)
1011 {
1012 cd->RetVal2 = RETURN_OK;
1013 }
1014
1015 /* indicate dir-mode for next if */
1016 }
1017 else
1018 {
1019 i = 1;
1020 }
1021
1022 UnLock(lock);
1023 }
1024
1025 /* Some magic to handle tick quoted pattern object names. Quite crude way to
1026 * handle it, but I couldn't think of anything better. - Piru
1027 */
1028 #if 1
1029 if (!i && cd->RetVal2 && !IsMatchPattern(*args.from, cd))
1030 {
1031 ULONG len;
1032 STRPTR pat;
1033
1034 //Printf("pattern check <%s>\n", *args.from);
1035
1036 len = (strlen(*args.from) << 1) + 3;
1037
1038 if ((pat = (STRPTR)AllocMem(len,
1039 MEMF_ANY)))
1040 {
1041 if (ParsePattern(*args.from, pat, len) > -1 &&
1042 strlen(pat) <= strlen(*args.from))
1043 {
1044 lock = Lock(pat, SHARED_LOCK);
1045 if (lock)
1046 {
1047 UnLock(lock);
1048
1049 strcpy(*args.from, pat);
1050 }
1051 }
1052
1053 FreeMem(pat, len);
1054 }
1055 }
1056 #endif
1057
1058 /* is source a directory */
1059 if (!i && cd->RetVal2 &&
1060 (lock = Lock(*args.from, SHARED_LOCK)))
1061 {
1062 if (Examine(lock, &cd->Fib))
1063 {
1064 cd->RetVal2 = RETURN_OK;
1065 if (cd->Mode != COPYMODE_COPY ||
1066 cd->Fib.fib_DirEntryType < 0)
1067 {
1068 UBYTE sep;
1069
1070 cd->Flags |= COPYFLAG_DEST_FILE;
1071
1072 /* produce missing destination directories */
1073 sep = *path;
1074 *path = 0;
1075
1076 if ((cd->CurDest = OpenDestDir(args.to, cd)))
1077 {
1078 *path = sep;
1079
1080 /* do the job */
1081 UnLock(lock);
1082 lock = 0;
1083 CopyMem(*args.from, cd->FileName,
1084 1 + strlen(*args.from));
1085 DoWork(FilePart(args.to), cd); /* on file call */
1086 UnLock(cd->CurDest);
1087 }
1088 }
1089 }
1090
1091 if (lock)
1092 {
1093 UnLock(lock);
1094 }
1095 }
1096
1097 if (lock == 0 && cd->Mode == COPYMODE_COPY && !TestFileSys(*args.from, cd))
1098 {
1099 UBYTE sep;
1100 cd->Flags |= COPYFLAG_DEST_FILE | COPYFLAG_SRCNOFILESYS;
1101 cd->RetVal2 = RETURN_OK;
1102
1103 /* produce missing destination directories */
1104 sep = *path;
1105 *path = 0;
1106
1107 if ((cd->CurDest = OpenDestDir(args.to, cd)))
1108 {
1109 *path = sep;
1110
1111 /* do the job */
1112 CopyMem(*args.from, cd->FileName, 1 + strlen(*args.from));
1113 DoWork(FilePart(args.to), cd); /* on file call */
1114 UnLock(cd->CurDest);
1115 }
1116 }
1117 }
1118 else if (i != -1)
1119 {
1120 cd->RetVal2 = RETURN_OK;
1121 }
1122
1123 if (!cd->RetVal && !cd->RetVal2 && !(cd->Flags & COPYFLAG_DEST_FILE) &&
1124 (cd->Destination = OpenDestDir(args.to, cd)))
1125 {
1126 while (cd->RetVal <= (args.errwarn ? RETURN_OK : RETURN_WARN)
1127 && *args.from && !CTRL_C)
1128 {
1129 PatCopy(*(args.from++), cd);
1130 }
1131
1132 UnLock(cd->Destination);
1133 }
1134 } /* else */
1135
1136 if (!(cd->Flags & COPYFLAG_DONE) && args.verbose &&
1137 !cd->RetVal && !cd->RetVal2)
1138 {
1139 PutStr(TEXT_NOTHING_DONE);
1140 }
1141
1142 } /* if (1) */
1143
1144 if (cd->Pattern)
1145 {
1146 FreeMem(cd->Pattern, patbufsize);
1147 }
1148 } /* else */
1149
1150 task->pr_WindowPtr = win;
1151
1152 FreeArgs(rda);
1153 } /* ReadArgs */
1154
1155 FreeDosObject(DOS_RDARGS, rda);
1156 } /* AllocDosObject */
1157
1158 if (!cd->RetVal2 && CTRL_C)
1159 {
1160 SetIoErr(ERROR_BREAK);
1161 cd->RetVal2 = RETURN_WARN;
1162 }
1163
1164 if (cd->RetVal)
1165 {
1166 cd->RetVal2 = cd->RetVal;
1167 }
1168
1169 if (args.errwarn && cd->RetVal2 == RETURN_WARN)
1170 {
1171 cd->RetVal2 = RETURN_ERROR;
1172 }
1173
1174 if (cd->CopyBuf)
1175 {
1176 FreeMem(cd->CopyBuf, cd->CopyBufLen);
1177 }
1178
1179 #undef SysBase
1180 #undef DOSBase
1181 }
1182 if (cd)
1183 {
1184 retval = cd->RetVal2;
1185 SetIoErr(cd->IoErr);
1186 FreeMem(cd, sizeof(*cd));
1187 }
1188 else if (DOSBase)
1189 {
1190 PrintFault(IoErr(), NULL);
1191 }
1192 if (DOSBase)
1193 {
1194 CloseLibrary((struct Library *)DOSBase);
1195 }
1196 return retval;
1197
1198 AROS_PROCFUNC_EXIT
1199 }
1200
1201 /* This code is pure and has library bases in explicitly allocated data structure */
1202 #define SysBase cd->SysBase
1203 #define DOSBase cd->DOSBase
1204
1205 void PatCopy(STRPTR name, struct CopyData *cd)
1206 {
1207 struct AnchorPath *APath;
1208 ULONG retval, doit = 0, deep = 0, failval = RETURN_WARN, first = 0;
1209
1210 #if DEBUG
1211 Printf("PatCopy(%s, .)\n", name);
1212 #endif
1213
1214 if ((cd->Mode == COPYMODE_COPY || (cd->Flags & COPYFLAG_ALL)) && !IsMatchPattern(name, cd))
1215 {
1216 first = 1; /* enter first directory (support of old copy style) */
1217 }
1218
1219 if (cd->Flags & COPYFLAG_ERRWARN)
1220 {
1221 failval = RETURN_OK;
1222 }
1223
1224 cd->CurDest = cd->Destination;
1225 cd->DestPathSize = 0;
1226
1227 if (cd->Mode == COPYMODE_COPY && !TestFileSys(name, cd))
1228 {
1229 cd->Flags |= COPYFLAG_SRCNOFILESYS;
1230 CopyMem(name, cd->FileName, 1 + strlen(name));
1231 DoWork(FilePart(name), cd);
1232 cd->Flags &= ~COPYFLAG_SRCNOFILESYS;
1233
1234 return;
1235 }
1236
1237 if ((APath = (struct AnchorPath *)AllocMem(sizeof(struct AnchorPath) + FILEPATH_SIZE,
1238 MEMF_PUBLIC | MEMF_CLEAR)))
1239 {
1240 int parentdirerr = 0;
1241
1242 APath->ap_BreakBits = SIGBREAKF_CTRL_C;
1243 APath->ap_Strlen = FILEPATH_SIZE;
1244
1245 for (retval = MatchFirst(name, APath);
1246 !retval && cd->RetVal <= failval && !cd->RetVal2;
1247 retval = MatchNext(APath)
1248 )
1249 {
1250 if (parentdirerr)
1251 {
1252 //Printf("ParentDir() fuxored last round! Would copy next files to SYS: !\n");
1253 retval = IoErr();
1254 if (!retval)
1255 cd->IoErr = retval = ERROR_INVALID_LOCK;
1256 break;
1257 }
1258
1259 if (doit)
1260 {
1261 DoWork(cd->Fib.fib_FileName, cd);
1262 doit = 0;
1263 }
1264
1265 if (deep) /* used for Deep checking */
1266 {
1267 ++cd->Deep;
1268 deep = 0;
1269 }
1270
1271 cd->Flags &= ~COPYFLAG_ENTERSECOND;
1272
1273 CopyMem(APath->ap_Buf, cd->FileName, FILEPATH_SIZE);
1274 CopyMem(&APath->ap_Info, &cd->Fib, sizeof(struct FileInfoBlock));
1275
1276 if (first && APath->ap_Info.fib_DirEntryType > 0)
1277 {
1278 #if USE_ALWAYSVERBOSE
1279 /* If the source is a directory, be verbose - Piru */
1280 cd->Flags |= COPYFLAG_VERBOSE;
1281 #endif
1282 APath->ap_Flags |= APF_DODIR;
1283 }
1284 else if (APath->ap_Flags & APF_DIDDIR)
1285 {
1286 BPTR i;
1287
1288 cd->Flags |= COPYFLAG_ENTERSECOND;
1289 APath->ap_Flags &= ~APF_DIDDIR;
1290 --cd->Deep;
1291
1292 if (cd->Mode == COPYMODE_DELETE || cd->Mode == COPYMODE_MOVE)
1293 {
1294 doit = 1;
1295 }
1296
1297 if ((i = cd->CurDest))
1298 {
1299 cd->CurDest = ParentDir(i);
1300 cd->DestPathSize = 0;
1301
1302 if (i != cd->Destination)
1303 {
1304 UnLock(i);
1305 }
1306
1307 if (!cd->CurDest)
1308 {
1309 parentdirerr = 1;
1310 continue;
1311 }
1312 }
1313 }
1314 else if (APath->ap_Info.fib_DirEntryType > 0)
1315 {
1316 doit = 1;
1317
1318 if (cd->Flags & COPYFLAG_ALL)
1319 {
1320 BOOL enter;
1321
1322 #if USE_SOFTLINKCHECK
1323
1324 #define BUFFERSIZE 512
1325 if (APath->ap_Info.fib_DirEntryType == ST_SOFTLINK)
1326 {
1327 UBYTE *buffer = AllocMem(BUFFERSIZE, MEMF_PUBLIC);
1328
1329 D(Printf("%s is a softlink\n", APath->ap_Info.fib_FileName));
1330 enter = FALSE;
1331 doit = FALSE;
1332
1333 if (buffer)
1334 {
1335 struct DevProc *dvp = GetDeviceProc("", NULL);
1336
1337 if (ReadLink(dvp->dvp_Port, APath->ap_Current->an_Lock, APath->ap_Info.fib_FileName, buffer, BUFFERSIZE - 1) > 0)
1338 {
1339 BOOL link_ok = FALSE;
1340 BPTR dir, lock;
1341
1342 buffer[BUFFERSIZE - 1] = '\0';
1343 D(Printf("Softlink target: %s\n", buffer));
1344
1345 dir = CurrentDir(APath->ap_Current->an_Lock);
1346 lock = Lock(buffer, SHARED_LOCK);
1347 if (lock)
1348 {
1349 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
1350
1351 if (fib)
1352 {
1353 if (Examine(lock, fib))
1354 {
1355 link_ok = TRUE;
1356 D(Printf("Target type: %ld\n", fib->fib_DirEntryType));
1357
1358 if (fib->fib_DirEntryType > 0)
1359 enter = TRUE;
1360 else
1361 /*
1362 * FIXME: This currently just prevents treating symlinks to files as
1363 * directories during copying.
1364 * DoWork() should be extended to handle symlinks correctly. BTW, how exactly ?
1365 */
1366 doit = FALSE;
1367 }
1368 FreeDosObject(DOS_FIB, fib);
1369 }
1370 UnLock(lock);
1371 }
1372
1373 CurrentDir(dir);
1374
1375 if (!link_ok)
1376 {
1377 Printf("Warning: Skipping dangling softlink %s -> %s\n",
1378 APath->ap_Info.fib_FileName, buffer);
1379 }
1380 }
1381 FreeDeviceProc(dvp);
1382 FreeMem(buffer, BUFFERSIZE);
1383 }
1384 }
1385 else
1386 #endif /* USE_SOFTLINKCHECK */
1387 enter = TRUE;
1388
1389 if (enter)
1390 {
1391 APath->ap_Flags |= APF_DODIR;
1392 deep = 1;
1393 }
1394 }
1395 }
1396 else if (!cd->Pattern || MatchPatternNoCase(cd->Pattern, APath->ap_Info.fib_FileName))
1397 {
1398 doit = 1;
1399 }
1400
1401 first = 0;
1402 }
1403
1404 MatchEnd(APath);
1405
1406 if (retval && retval != ERROR_NO_MORE_ENTRIES)
1407 {
1408 LONG ioerr = IoErr();
1409 #if USE_ALWAYSVERBOSE
1410 cd->Flags |= COPYFLAG_VERBOSE;
1411 #endif
1412 Printf("%s - ", APath->ap_Info.fib_FileName);
1413 PrintFault(ioerr, NULL);
1414 cd->IoErr = ioerr;
1415
1416 cd->RetVal2 = RETURN_FAIL;
1417 }
1418
1419 if (doit)
1420 {
1421 DoWork(cd->Fib.fib_FileName, cd);
1422 }
1423
1424 /* No need to clear the flags here, as they are cleared on next PatJoin
1425 call (DoWork is not called first round, as lock is zero!). */
1426
1427 FreeMem(APath, sizeof(struct AnchorPath) + FILEPATH_SIZE);
1428 }
1429 else
1430 {
1431 cd->RetVal = RETURN_FAIL;
1432
1433 if (!(cd->Flags & COPYFLAG_QUIET))
1434 {
1435 PrintFault(ERROR_NO_FREE_STORE, NULL);
1436 }
1437 }
1438
1439 if (cd->CurDest && cd->CurDest != cd->Destination)
1440 {
1441 UnLock(cd->CurDest);
1442 }
1443 }
1444
1445
1446 LONG IsPattern(STRPTR name, struct CopyData *cd)
1447 {
1448 LONG a, ret = -1;
1449 STRPTR buffer;
1450
1451 a = (strlen(name) << 1) + 3;
1452
1453 if ((buffer = (STRPTR)AllocMem(a, MEMF_ANY)))
1454 {
1455 ret = ParsePattern(name, buffer, a);
1456 FreeMem(buffer, a);
1457 }
1458
1459 if (ret == -1)
1460 {
1461 cd->IoErr = ERROR_NO_FREE_STORE;
1462 }
1463
1464 return ret;
1465 }
1466
1467
1468 LONG IsMatchPattern(STRPTR name, struct CopyData *cd)
1469 {
1470 struct AnchorPath ap;
1471 LONG ret = -1;
1472
1473 ap.ap_BreakBits = 0;
1474 ap.ap_Flags = APF_DOWILD;
1475 ap.ap_Strlen = 0;
1476
1477 if (MatchFirst(name, &ap) == 0)
1478 {
1479 ret = (ap.ap_Flags & APF_ITSWILD) ? TRUE : FALSE;
1480
1481 MatchEnd(&ap);
1482 }
1483
1484 return ret;
1485 }
1486
1487
1488 LONG KillFile(STRPTR name, ULONG doit, struct CopyData *cd)
1489 {
1490 if (doit)
1491 {
1492 SetProtection(name, 0);
1493 }
1494
1495 return DeleteFile(name);
1496 }
1497
1498
1499 BPTR OpenDestDir(STRPTR name, struct CopyData *cd)
1500 {
1501 LONG a, err = 0, cr = 0;
1502 BPTR dir;
1503 STRPTR ptr = name;
1504 UBYTE as;
1505
1506 if ((cd->Mode == COPYMODE_COPY || cd->Mode == COPYMODE_MOVE) && !TestFileSys(name, cd))
1507 {
1508 cd->Flags |= COPYFLAG_DESNOFILESYS;
1509 CopyMem(name, cd->DestName, 1 + strlen(name));
1510
1511 return Lock("", SHARED_LOCK);
1512 }
1513
1514 while (!err && *ptr != 0)
1515 {
1516 while (*ptr && *ptr != '/')
1517 {
1518 ++ptr;
1519 }
1520
1521 as = *ptr;
1522 *ptr = 0;
1523
1524 if ((a = TestDest(name, 1, cd)) == TESTDEST_CANTDELETE)
1525 {
1526 if (!(cd->Flags & COPYFLAG_QUIET))
1527 {
1528 PutStr(TEXT_ERR_DEST_DIR);
1529 }
1530
1531 err = 2;
1532 }
1533 else if (a < 0)
1534 {
1535 err = 1;
1536 }
1537 else if (a != TESTDEST_DIR_OK)
1538 {
1539 if ((dir = CreateDir(name)))
1540 {
1541 ++cr;
1542
1543 if ((cd->Flags & COPYFLAG_VERBOSE))
1544 {
1545 PrintName(name, 1, 1, 1, cd);
1546 Printf("%s\n", TEXT_CREATED);
1547 }
1548
1549 UnLock(dir);
1550 }
1551 else
1552 {
1553 cd->IoErr = IoErr();
1554 if (!(cd->Flags & COPYFLAG_QUIET))
1555 {
1556 PrintNotDone(name, TEXT_CREATED, 1, 1, cd);
1557 }
1558
1559 err = 2;
1560 }
1561 }
1562
1563 *ptr = as;
1564
1565 /* 26-Oct-2003 bugfix: Don't scan past end of the string.
1566 * as is the old char, if '\0' we've reached the end of the
1567 * string. - Piru
1568 */
1569 if (as)
1570 {
1571 ptr++;
1572 }
1573 }
1574
1575 if (err)
1576 {
1577 cd->RetVal = RETURN_ERROR;
1578
1579 if (!(cd->Flags & COPYFLAG_QUIET) && err == 1)
1580 {
1581 PrintNotDone(name, TEXT_OPENED_FOR_OUTPUT, 1, 1, cd);
1582 }
1583
1584 return 0;
1585 }
1586
1587 if (cd->Mode == COPYMODE_MAKEDIR && !cr && !(cd->Flags & COPYFLAG_QUIET))
1588 {
1589 cd->IoErr = ERROR_OBJECT_EXISTS;
1590 PrintNotDone(name, TEXT_CREATED, 1, 1, cd);
1591 }
1592
1593 return Lock(name, SHARED_LOCK);
1594 }
1595
1596
1597 void PrintName(CONST_STRPTR name, ULONG deep, ULONG dir, ULONG txt, struct CopyData *cd)
1598 {
1599 #if 0
1600 deep %= PRINTOUT_SPACES; /* reduce number of spaces */
1601 /* This produces an error with MaxonC++ */
1602 #endif
1603
1604 PutStr(" ");
1605 if (deep)
1606 {
1607 while (--deep)
1608 {
1609 PutStr(" ");
1610 }
1611 }
1612
1613 if (dir)
1614 {
1615 PutStr(" ");
1616 }
1617
1618 #if 0
1619 if ((deep = strlen(name)) > PRINTOUT_SIZE) /* reduce name size */
1620 {
1621 name += deep-PRINTOUT_SIZE;
1622 PutStr("...");
1623 }
1624 #endif
1625
1626 Printf((dir ? TEXT_DIRECTORY : (STRPTR) "%s"), name);
1627
1628 if (!dir && txt)
1629 {
1630 PutStr("..");
1631 }
1632
1633 Flush(Output());
1634 }
1635
1636
1637 void PrintNotDone(CONST_STRPTR name, CONST_STRPTR txt, ULONG deep, ULONG dir, struct CopyData *cd)
1638 {
1639 #if !USE_ALWAYSVERBOSE
1640 if (name)
1641 {
1642 PrintName(name, deep, dir, 1, cd);
1643 }
1644 #endif
1645
1646 Printf(TEXT_NOT_DONE, txt);
1647 if (cd->IoErr != 0)
1648 {
1649 PutStr(" - ");
1650 PrintFault(cd->IoErr, NULL);
1651 }
1652 else
1653 PutStr("\n");
1654 }
1655
1656
1657 /* returns value, when it seems to be a filesystem */
1658 ULONG TestFileSys(STRPTR name, struct CopyData *cd)
1659 {
1660 STRPTR n = name;
1661 ULONG ret = 1;
1662
1663 while (*n && *n != ':')
1664 {
1665 ++n;
1666 }
1667
1668 if (*(n++) == ':')
1669 {
1670 UBYTE a;
1671
1672 a = *n;
1673 *n = 0;
1674 ret = IsFileSystem(name);
1675 *n = a;
1676 }
1677
1678 return ret;
1679 }
1680
1681
1682 void DoWork(STRPTR name, struct CopyData *cd)
1683 {
1684 BPTR pdir, lock = 0;
1685 CONST_STRPTR printerr = NULL, printok = "";
1686
1687 #if DEBUG
1688 Printf("DoWork(%s, .)\n", name);
1689 #endif
1690
1691 if (cd->RetVal > (cd->Flags & COPYFLAG_ERRWARN ? RETURN_OK : RETURN_WARN) || cd->RetVal2)
1692 {
1693 #if DEBUG
1694 Printf("DoWork(RetVal %ld)\n", cd->RetVal);
1695 #endif
1696 return;
1697 }
1698
1699 if (cd->Mode != COPYMODE_DELETE && !(cd->Flags & COPYFLAG_DESNOFILESYS))
1700 {
1701 if (!cd->DestPathSize)
1702 {
1703 if (!NameFromLock(cd->CurDest, cd->DestName, FILEPATH_SIZE))
1704 {
1705 cd->RetVal2 = RETURN_FAIL;
1706
1707 #if DEBUG
1708 Printf("DoWork(NameFromLock RetVal %ld)\n", cd->RetVal);
1709 #endif
1710
1711 return;
1712 }
1713
1714 cd->DestPathSize = strlen(cd->DestName);
1715 }
1716
1717 cd->DestName[cd->DestPathSize] = 0;
1718 AddPart(cd->DestName, name, FILEPATH_SIZE);
1719 }
1720
1721 if (cd->Flags & (COPYFLAG_SRCNOFILESYS|COPYFLAG_DESNOFILESYS))
1722 {
1723 ULONG res = 0;
1724 BPTR in, out;
1725 CONST_STRPTR txt = TEXT_OPENED_FOR_OUTPUT;
1726
1727 #if DEBUG
1728 Printf("Partly DIRECT mode active now (%s - %s)\n", cd->FileName,
1729 cd->DestName);
1730 #endif
1731
1732 if ((in = Open(cd->FileName, MODE_OLDFILE)))
1733 {
1734 txt = cd->Mode == COPYMODE_MOVE ? TEXT_MOVED : TEXT_COPIED;
1735
1736 if ((out = Open(cd->DestName, MODE_NEWFILE)))
1737 {
1738 ULONG h;
1739
1740 h = CopyFile(in, out, cd->BufferSize, cd);
1741 if (h != 0)
1742 cd->IoErr = IoErr();
1743 Close(out);
1744 Close(in);
1745 in = BNULL;
1746
1747 if (!h)
1748 {
1749 if (cd->Mode == COPYMODE_MOVE)
1750 {
1751 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
1752 {
1753 res = 1;
1754 }
1755 }
1756 else
1757 {
1758 res = 1;
1759 }
1760 } else {
1761 KillFile(cd->DestName, 0, cd);
1762 }
1763 }
1764 else
1765 cd->IoErr = IoErr();
1766
1767 if (in != BNULL)
1768 Close(in);
1769 }
1770 else
1771 cd->IoErr = IoErr();
1772
1773 if (!res && !(cd->Flags & COPYFLAG_QUIET))
1774 {
1775 PrintNotDone(name, txt, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd);
1776 }
1777 else
1778 {
1779 cd->Flags |= COPYFLAG_DONE;
1780
1781 if ((cd->Flags & COPYFLAG_VERBOSE))
1782 {
1783 Printf("%s\n", txt);
1784 }
1785 }
1786
1787 #if DEBUG
1788 PutStr("DoWork(done)\n");
1789 #endif
1790 return;
1791 }
1792
1793 if (!(lock = Lock(cd->FileName, SHARED_LOCK)))
1794 {
1795 cd->RetVal = RETURN_WARN;
1796 cd->IoErr = IoErr();
1797
1798 if (!(cd->Flags & COPYFLAG_QUIET))
1799 {
1800 PrintNotDone(cd->Fib.fib_FileName, TEXT_READ, cd->Deep,
1801 cd->Fib.fib_DirEntryType > 0, cd);
1802 }
1803
1804 #if DEBUG
1805 Printf("DoWork(Lock RetVal %ld)\n", cd->RetVal);
1806 #endif
1807 return;
1808 }
1809
1810 if (!(pdir = ParentDir(lock)))
1811 {
1812 cd->RetVal = RETURN_ERROR;
1813
1814 if (cd->Mode == COPYMODE_DELETE)
1815 {
1816 if (!(cd->Flags & COPYFLAG_QUIET))
1817 {
1818 Printf(" %s ", cd->FileName);
1819 Printf(TEXT_NOT_DONE, TEXT_DELETED);
1820 Printf("%s\n", TEXT_ERR_DELETE_DEVICE);
1821 }
1822 }
1823
1824 UnLock(lock);
1825
1826 #if DEBUG
1827 Printf("DoWork(ParentDir %ld)\n", cd->RetVal);
1828 #endif
1829 return;
1830 }
1831
1832 UnLock(pdir);
1833
1834 if (!(cd->Flags & COPYFLAG_QUIET))
1835 {
1836 if ((cd->Flags & COPYFLAG_VERBOSE))
1837 {
1838 PrintName(name, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd->Fib.fib_DirEntryType < 0 ||
1839 (cd->Flags & COPYFLAG_ALL ? cd->Mode != COPYMODE_DELETE : cd->Mode != COPYMODE_COPY) ||
1840 cd->Flags & COPYFLAG_ENTERSECOND, cd);
1841 }
1842 }
1843
1844 if ((cd->Flags & COPYFLAG_ENTERSECOND) || (cd->Mode == COPYMODE_DELETE &&
1845 (!(cd->Flags & COPYFLAG_ALL) || cd->Fib.fib_DirEntryType < 0)))
1846 {
1847 UnLock(lock);
1848 lock = 0;
1849
1850 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
1851 {
1852 printok = TEXT_DELETED;
1853 }
1854 else
1855 {
1856 cd->RetVal = RETURN_WARN;
1857 printerr = TEXT_DELETED;
1858 }
1859 }
1860 else if (cd->Mode == COPYMODE_DELETE)
1861 {
1862 ;
1863 }
1864 else if (cd->Fib.fib_DirEntryType > 0)
1865 {
1866 LONG a;
1867
1868 if ((cd->Flags & COPYFLAG_ALL || cd->Mode == COPYMODE_LINK ||
1869 cd->Mode == COPYMODE_MOVE) && TestLoop(lock, cd->CurDest, cd))
1870 {
1871 printok = 0;
1872 cd->RetVal = RETURN_ERROR;
1873
1874 if (!(cd->Flags & COPYFLAG_QUIET))
1875 {
1876 if (!(cd->Flags & COPYFLAG_VERBOSE))
1877 {
1878 PrintName(name, cd->Deep, 1, 1, cd);
1879 }
1880
1881 Printf(TEXT_NOT_DONE, TEXT_ENTERED);
1882 PutStr(TEXT_ERR_INFINITE_LOOP);
1883 }
1884 }
1885 else if ((a = TestDest(cd->DestName, 1, cd)) < 0)
1886 {
1887 printerr = TEXT_CREATED;
1888 cd->RetVal = RETURN_ERROR;
1889 }
1890 else if (cd->Flags & COPYFLAG_ALL)
1891 {
1892 BPTR i;
1893
1894 i = cd->CurDest;
1895 cd->DestPathSize = 0;
1896
1897 if (a == TESTDEST_DIR_OK)
1898 {
1899 if (!(cd->CurDest = Lock(cd->DestName, SHARED_LOCK)))
1900 {
1901 cd->IoErr = IoErr();
1902 printerr = TEXT_ENTERED;
1903 cd->RetVal = RETURN_ERROR;
1904 }
1905 else
1906 {
1907 #if USE_ALWAYSVERBOSE
1908 printok = "";
1909 #else
1910 printok = TEXT_ENTERED;
1911 #endif
1912 }
1913 }
1914 else if ((cd->CurDest = CreateDir(cd->DestName)))
1915 {
1916 UnLock(cd->CurDest);
1917
1918 if ((cd->CurDest = Lock(cd->DestName, SHARED_LOCK)))
1919 {
1920 printok = TEXT_CREATED;
1921 }
1922 else
1923 {
1924 cd->IoErr = IoErr();
1925 printerr = TEXT_ENTERED;
1926 cd->RetVal = RETURN_ERROR;
1927 }
1928 }
1929 else
1930 {
1931 cd->IoErr = IoErr();
1932 printerr = TEXT_CREATED;
1933 cd->RetVal = RETURN_ERROR;
1934 }
1935
1936 if (!cd->CurDest)
1937 {
1938 cd->CurDest = i;
1939 }
1940 else if (i != cd->Destination)
1941 {
1942 UnLock(i);
1943 }
1944 }
1945 else if (cd->Mode == COPYMODE_MOVE)
1946 {
1947 if (Rename(cd->FileName, cd->DestName))
1948 {
1949 printok = TEXT_RENAMED;
1950 }
1951 else
1952 {
1953 cd->IoErr = IoErr();
1954 printerr = TEXT_RENAMED;
1955 cd->RetVal = RETURN_WARN;
1956 }
1957 }
1958 else if (cd->Mode == COPYMODE_LINK)
1959 {
1960 if (!(cd->Flags & COPYFLAG_FORCELINK))
1961 {
1962 printok = 0;
1963 cd->RetVal = RETURN_WARN;
1964
1965 if (!(cd->Flags & COPYFLAG_QUIET))
1966 {
1967 if (!(cd->Flags & COPYFLAG_VERBOSE))
1968 {
1969 PrintName(name, cd->Deep, 1, 1, cd);
1970 }
1971
1972 Printf(TEXT_NOT_DONE, TEXT_LINKED);
1973 PutStr(TEXT_ERR_FORCELINK);
1974 }
1975 }
1976 else if (LinkFile(lock, cd->DestName, cd->Flags & COPYFLAG_SOFTLINK, cd))
1977 {
1978 printok = TEXT_LINKED;
1979 }
1980 else
1981 {
1982 printerr = TEXT_LINKED;
1983 cd->RetVal = RETURN_WARN;
1984 }
1985 }
1986 else /* COPY mode only displays directories, when not ALL */
1987 {
1988 printok = 0;
1989
1990 if (!(cd->Flags & COPYFLAG_QUIET))
1991 {
1992 if (cd->Flags & COPYFLAG_VERBOSE)
1993 {
1994 PutStr("\n");
1995 }
1996 }
1997 }
1998 }
1999 else
2000 {
2001 /* test for existing destination file */
2002 if (TestDest(cd->DestName, 0, cd) < 0)
2003 {
2004 printerr = TEXT_OPENED_FOR_OUTPUT;
2005 }
2006 else if (cd->Mode == COPYMODE_MOVE && Rename(cd->FileName, cd->DestName))
2007 {
2008 printok = TEXT_RENAMED;
2009 }
2010 else if (cd->Mode == COPYMODE_LINK)
2011 {
2012 if (!(cd->Flags & COPYFLAG_SOFTLINK) && LinkFile(lock, cd->DestName, 0, cd))
2013 {
2014 printok = TEXT_LINKED;
2015 }
2016 else
2017 {
2018 printerr = TEXT_LINKED;
2019 cd->RetVal = RETURN_WARN;
2020
2021 if (cd->Flags & COPYFLAG_SOFTLINK)
2022 {
2023 cd->IoErr = ERROR_OBJECT_WRONG_TYPE;
2024 }
2025 }
2026 }
2027 else
2028 {
2029 ULONG res = 0, h;
2030 BPTR in, out;
2031 CONST_STRPTR txt = TEXT_OPENED_FOR_OUTPUT;
2032
2033 if ((out = Open(cd->DestName, MODE_NEWFILE)))
2034 {
2035 ULONG kill = 1;
2036
2037 txt = cd->Mode == COPYMODE_MOVE ? TEXT_MOVED : TEXT_COPIED;
2038 UnLock(lock);
2039 lock = 0;
2040
2041 if ((in = Open(cd->FileName, MODE_OLDFILE)))
2042 {
2043 h = CopyFile(in, out, cd->BufferSize, cd);
2044 if (h != 0)
2045 cd->IoErr = IoErr();
2046 Close(out);
2047 out = BNULL;
2048 Close(in);
2049
2050 if (!h)
2051 {
2052 kill = 0;
2053
2054 if (cd->Mode == COPYMODE_MOVE)
2055 {
2056 if (KillFile(cd->FileName, cd->Flags & COPYFLAG_FORCEDELETE, cd))
2057 {
2058 res = 1;
2059 }
2060 }
2061 else
2062 {
2063 res = 1;
2064 }
2065 }
2066 }
2067 else cd->IoErr = IoErr();
2068
2069 if (out)
2070 {
2071 Close(out);
2072 }
2073
2074 if (kill)
2075 {
2076 KillFile(cd->DestName, 0, cd);
2077 }
2078 }
2079 else cd->IoErr = IoErr();
2080
2081 if (!res)
2082 {
2083 printerr = txt;
2084 cd->RetVal = RETURN_WARN;
2085 }
2086 else
2087 {
2088 printok = txt;
2089 }
2090 }
2091 }
2092
2093 if (printerr && !(cd->Flags & COPYFLAG_QUIET))
2094 {
2095 PrintNotDone(name, printerr, cd->Deep, cd->Fib.fib_DirEntryType > 0, cd);
2096 }
2097 else if (printok)
2098 {
2099 cd->Flags |= COPYFLAG_DONE;
2100
2101 if (!(cd->Flags & COPYFLAG_QUIET))
2102 {
2103 if ((cd->Flags & COPYFLAG_VERBOSE))
2104 {
2105 Printf("%s\n", printok);
2106 }
2107 }
2108
2109 if (cd->Mode != COPYMODE_DELETE)
2110 {
2111 SetData(cd->DestName, cd);
2112 }
2113 }
2114
2115 if (lock)
2116 {
2117 UnLock(lock);
2118 }
2119 }
2120
2121
2122 LONG CopyFile(BPTR from, BPTR to, ULONG bufsize, struct CopyData *cd)
2123 {
2124 STRPTR buffer;
2125 LONG s, err = 0;
2126
2127 if (cd->CopyBuf)
2128 {
2129 buffer = cd->CopyBuf;
2130 bufsize = cd->CopyBufLen;
2131 }
2132 else
2133 {
2134 do
2135 {
2136 buffer = (STRPTR)AllocMem(bufsize, MEMF_PUBLIC);
2137 if (buffer)
2138 {
2139 cd->CopyBuf = buffer;
2140 cd->CopyBufLen = bufsize;
2141 break;
2142 }
2143
2144 bufsize >>= 1;
2145
2146 } while (bufsize >= 512);
2147 }
2148
2149 if (buffer)
2150 {
2151 #if USE_BOGUSEOFWORKAROUND
2152 struct FileInfoBlock *fib = (struct FileInfoBlock *) buffer; /* NOTE: bufsize is min 512 bytes */
2153
2154 if (ExamineFH(from, fib))
2155 {
2156 #warning "****** WARNING: No largefile support! ******"
2157 ULONG filesize = fib->fib_Size, copied = 0;
2158
2159 /*Printf("filesize: %lu\n", filesize);*/
2160
2161 do
2162 {
2163 ULONG brk = CTRL_C;
2164 if (brk || (s = Read(from, buffer, bufsize)) == -1 || Write(to, buffer, s) != s)
2165 {
2166 if (brk)
2167 {
2168 cd->IoErr = ERROR_BREAK;
2169 }
2170 err = RETURN_FAIL;
2171 break;
2172 }
2173 else if (s == 0 && copied < filesize)
2174 {
2175 /* premature EOF with buggy fs */
2176 err = RETURN_FAIL;
2177 break;
2178 }
2179
2180 copied += s;
2181
2182 } while (copied < filesize);
2183
2184 /*{ LONG ioerr = IoErr();
2185 Printf("copied %lu/%lu\n", copied, filesize);
2186 SetIoErr(ioerr);}*/
2187 }
2188 else
2189 #endif /* USE_BOGUSEOFWORKAROUND */
2190 {
2191 /* Stream or so, copy until EOF or error */
2192 do
2193 {
2194 ULONG brk = CTRL_C;
2195 /* AROS: This flush appears to be required if reading from '*'
2196 * Maybe a bug in Read(), or AROS buffering?
2197 */
2198 Flush(from);
2199 if (brk || (s = Read(from, buffer, bufsize)) == -1 || Write(to, buffer, s) != s)
2200 {
2201 if (brk)
2202 {
2203 cd->IoErr = ERROR_BREAK;
2204 }
2205 err = RETURN_FAIL;
2206 break;
2207 }
2208 } while (s > 0);
2209 }
2210
2211 /* Freed at exit to avoid fragmentation */
2212 /*FreeMem(buffer, bufsize);*/
2213 }
2214 else
2215 {
2216 err = RETURN_FAIL;
2217 }
2218
2219 return err;
2220 }
2221
2222
2223 /* Softlink's path starts always with device name! f.e. "Ram Disk:T/..." */
2224 LONG LinkFile(BPTR from, STRPTR to, ULONG soft, struct CopyData *cd)
2225 {
2226 if (soft)
2227 {
2228 LONG ret = FALSE;
2229 UBYTE *name;
2230
2231 name = AllocMem(FILEPATH_SIZE, MEMF_ANY);
2232 if (name)
2233 {
2234 if (NameFromLock(from, name, FILEPATH_SIZE))
2235 {
2236 ret = MakeLink(to, (SIPTR)name, LINK_SOFT);
2237 }
2238
2239 FreeMem(name, FILEPATH_SIZE);
2240 }
2241
2242 return ret;
2243 }
2244 else
2245 {
2246 return MakeLink(to, (SIPTR)from, LINK_HARD);
2247 }
2248 }
2249
2250
2251 /* return 0 means no loop, return != 0 means loop found */
2252 ULONG TestLoop(BPTR srcdir, BPTR destdir, struct CopyData *cd)
2253 {
2254 ULONG loop = 0;
2255 BPTR par, lock;
2256
2257 lock = destdir;
2258
2259 if (SameDevice(srcdir, destdir))
2260 {
2261 do
2262 {
2263 if (!SameLock(srcdir, lock))
2264 {
2265 loop = 1;
2266 }
2267 else
2268 {
2269 par = ParentDir(lock);
2270
2271 if (lock != destdir)
2272 {
2273 UnLock(lock);
2274 }
2275
2276 lock = par;
2277 }
2278 }
2279 while(!loop && lock);
2280 }
2281
2282 if (lock != destdir)
2283 {
2284 UnLock(lock);
2285 }
2286
2287 return loop;
2288 }
2289
2290
2291 void SetData(STRPTR name, struct CopyData *cd)
2292 {
2293 if (cd->Flags & COPYFLAG_NOPRO)
2294 {
2295 /* Is already set! - Piru */
2296 //SetProtection(name, 0);
2297 }
2298 else
2299 {
2300 SetProtection(name, cd->Fib.fib_Protection & (ULONG) ~FIBF_ARCHIVE);
2301 }
2302
2303 if (cd->Flags & COPYFLAG_DATES)
2304 {
2305 SetFileDate(name, &cd->Fib.fib_Date);
2306 }
2307
2308 if (cd->Flags & COPYFLAG_COMMENT)
2309 {
2310 SetComment(name, cd->Fib.fib_Comment);
2311 }
2312 }
2313
2314
2315 LONG TestDest(STRPTR name, ULONG type, struct CopyData *cd)
2316 {
2317 LONG ret = TESTDEST_ERROR;
2318 BPTR lock;
2319
2320 if ((lock = Lock(name, SHARED_LOCK)))
2321 {
2322 struct FileInfoBlock *fib;
2323
2324 if ((fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
2325 {
2326 if (Examine(lock, fib))
2327 {
2328 UnLock(lock);
2329 lock = 0;
2330
2331 if (type)
2332 {
2333 if (fib->fib_DirEntryType > 0)
2334 {
2335 ret = TESTDEST_DIR_OK;
2336 }
2337 else if (!(cd->Flags & COPYFLAG_DONTOVERWRITE))
2338 {
2339 if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2340 {
2341 ret = TESTDEST_DELETED;
2342 }
2343 }
2344 else
2345 {
2346 ret = TESTDEST_CANTDELETE;
2347 }
2348 }
2349 else if (cd->Flags & COPYFLAG_DONTOVERWRITE)
2350 {
2351 if (cd->Flags & COPYFLAG_NEWER)
2352 {
2353 if (CheckVersion( cd ) == CHECKVER_DESTOLDER )
2354 {
2355 if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2356 {
2357 ret = TESTDEST_DELETED;
2358 }
2359 }
2360 else
2361 {
2362 ret = TESTDEST_CANTDELETE;
2363 }
2364 }
2365 else /* normal "dont overwrite mode" */
2366 {
2367 ret = TESTDEST_CANTDELETE;
2368 }
2369 }
2370 else if (KillFile(name, cd->Flags & COPYFLAG_FORCEOVERWRITE, cd))
2371 {
2372 ret = TESTDEST_DELETED;
2373 }
2374 }
2375
2376 FreeDosObject(DOS_FIB, fib);
2377 }
2378
2379 if (lock)
2380 {
2381 UnLock(lock);
2382 }
2383 }
2384 else
2385 {
2386 ret = TESTDEST_NONE;
2387 }
2388
2389 if (ret == TESTDEST_CANTDELETE)
2390 {
2391 cd->IoErr = ERROR_OBJECT_EXISTS;
2392 }
2393 else if (ret == TESTDEST_ERROR)
2394 {
2395 cd->IoErr = IoErr();
2396 }
2397
2398 return ret;
2399 }
2400
2401 /*
2402 ** We compare current file versions and return the result
2403 ** see CHECKVER_#? values
2404 */
2405
2406 static LONG CheckVersion( struct CopyData *cd )
2407 {
2408 struct VersionData vds;
2409 struct VersionData vdd;
2410 LONG resversion = CHECKVER_EQUAL;
2411 LONG resdate = CHECKVER_EQUAL;
2412
2413 if( VersionFind( cd->FileName, &vds, cd ) )
2414 {
2415 if( VersionFind( cd->DestName, &vdd, cd ) )
2416 {
2417 /* version and revision must be available to ensure a proper operation */
2418 if( ((vdd.vd_Version != -1) && (vds.vd_Version != -1) && (vdd.vd_Revision != -1) && (vds.vd_Revision != -1)) )
2419 {
2420 /* first we make the stuff comparable. If one component is missing we reset both */
2421 if( vdd.vd_Year == -1 || vds.vd_Year == -1 )
2422 {
2423 vdd.vd_Year = 0;
2424 vds.vd_Year = 0;
2425 }
2426 if( vdd.vd_Month == -1 || vds.vd_Month == -1 )
2427 {
2428 vdd.vd_Month = 0;
2429 vds.vd_Month = 0;
2430 }
2431 if( vdd.vd_Day == -1 || vds.vd_Day == -1 )
2432 {
2433 vdd.vd_Day = 0;
2434 vds.vd_Day = 0;
2435 }
2436
2437 /* check version */
2438 resversion = CHECKVER_DESTOLDER;
2439 if( ((vdd.vd_Version == vds.vd_Version) && vdd.vd_Revision == vds.vd_Revision ) )
2440 {
2441 resversion = CHECKVER_EQUAL;
2442 }
2443 else if( (vdd.vd_Version > vds.vd_Version) ||
2444 ((vdd.vd_Version == vds.vd_Version) && vdd.vd_Revision > vds.vd_Revision ) )
2445 {
2446 resversion = CHECKVER_DESTNEWER;
2447 }
2448 /* check date */
2449
2450 resdate = CHECKVER_DESTOLDER;
2451 if( ((vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month == vds.vd_Month) && (vdd.vd_Day == vds.vd_Day) ) )
2452 {
2453 resdate = CHECKVER_EQUAL;
2454 }
2455 else
2456 {
2457 if( ( (vdd.vd_Year > vds.vd_Year ) ||
2458 ( (vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month > vds.vd_Month ) ) ||
2459 ( (vdd.vd_Year == vds.vd_Year) && (vdd.vd_Month == vds.vd_Month ) && (vdd.vd_Day > vds.vd_Day ) ) ))
2460 {
2461 resdate = CHECKVER_DESTNEWER;
2462 }
2463 }
2464
2465 /* plausible check */
2466 if( ((resversion == CHECKVER_DESTNEWER) && (resdate == CHECKVER_DESTOLDER)) || /* newer version with older date */
2467 ((resversion == CHECKVER_DESTOLDER) && (resdate == CHECKVER_DESTNEWER)) ) /* older version with newer date */
2468 {
2469 /* we maybe should inform the user about this */
2470 return( CHECKVER_EQUAL );
2471 }
2472 }
2473 }
2474 }
2475 /* compose result */
2476
2477 if( (resversion == resdate) || (resversion == CHECKVER_EQUAL) )
2478 {
2479 return( resdate );
2480 }
2481 else
2482 {
2483 return( resversion );
2484 }
2485 }
2486
2487
2488
2489 /*
2490 ** Searches the given file for a version string and fills version data struct with the result.
2491 ** Returns false if no version was found. Returns true if the version got parsed and version data
2492 ** is valid.
2493 */
2494
2495 #define VERSBUFFERSIZE 4096 /* must be as big as the biggest version string we want to handle. */
2496
2497 static BOOL VersionFind( CONST_STRPTR path, struct VersionData *vds, struct CopyData *cd)
2498 {
2499 BPTR handle;
2500 STRPTR buf;
2501 ULONG i, rc;
2502
2503 rc = FALSE;
2504
2505 if ( (buf = AllocVec(VERSBUFFERSIZE, MEMF_PUBLIC | MEMF_CLEAR)) )
2506 {
2507 if ( (handle = Open(path, MODE_OLDFILE)) )
2508 {
2509 long index = 0;
2510
2511 while( ( (index += Read(handle, &buf[index], VERSBUFFERSIZE-index)) > 5) && !rc )
2512 {
2513 for (i = 0; i < index-5; i++) {
2514 if( buf[i] == '$' && buf[i+1] == 'V' && buf[i+2] == 'E' && buf[i+3] == 'R' && buf[i+4] == ':' ) {
2515 CopyMem( &buf[i], buf, index-i );
2516 index -= i;
2517 (index += Read(handle, &buf[index], VERSBUFFERSIZE-index));
2518 /* now the version string is aligned and complete in buffer */
2519 makeversionfromstring( buf, vds, cd );
2520 rc = TRUE;
2521 break;
2522 }
2523 }
2524 CopyMem( &buf[index-5], &buf[0], 5 );
2525 index = 5;
2526 }
2527 Close(handle);
2528 }
2529 FreeVec(buf);
2530 }
2531 return (rc);
2532 }
2533
2534
2535 /*
2536 ** This function extracts the version information from a given version string.
2537 ** the result will be store in the given version data structure.
2538 **
2539 ** NOTE: There is no need to preset the version data struct. All fields will
2540 ** be reset to defaults, so in case of a faulty version string the result data
2541 ** will be checkable.
2542 */
2543
2544 static
2545 void makeversionfromstring( STRPTR buffer, struct VersionData *vd, struct CopyData *cd)
2546 {
2547 LONG pos;
2548 ULONG tmp;
2549 STRPTR name;
2550
2551 /* reset data field */
2552
2553 vd->vd_Name[0] = '\0';
2554 vd->vd_Version = -1;
2555 vd->vd_Revision = -1;
2556 vd->vd_Day = -1;
2557 vd->vd_Month = -1;
2558 vd->vd_Year = -1;
2559
2560 buffer = skipspaces( buffer ); /* skip before $VER: */
2561 buffer = skipnonspaces( buffer ); /* skip $VER: */
2562 buffer = skipspaces( buffer ); /* skip spaces before tool name */
2563 name = buffer;
2564 buffer = skipnonspaces( buffer ); /* skip name of tool */
2565
2566 if( (tmp = ((long) buffer - (long) name) ) && *buffer )
2567 {
2568 CopyMem( name, vd->vd_Name, MIN( tmp, VDNAMESIZE-1) );
2569 vd->vd_Name[MIN( tmp, VDNAMESIZE-1)] = '\0'; /* terminate name string inside target buffer */
2570
2571 buffer = skipspaces( buffer ); /* skip spaces before version */
2572 if( *buffer ) {
2573
2574 /* Do version */
2575
2576 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2577 {
2578 vd->vd_Version = tmp;
2579
2580 /* Do revision */
2581
2582 buffer += pos;
2583 buffer = skipspaces(buffer);
2584 if (*buffer++ == '.')
2585 {
2586 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2587 {
2588 vd->vd_Revision = tmp;
2589 buffer += pos;
2590 buffer = skipspaces(buffer);
2591 if (*buffer++ == '(')
2592 {
2593 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2594 {
2595 vd->vd_Day = tmp;
2596 buffer += pos;
2597 if (*buffer++ == '.')
2598 {
2599 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2600 {
2601 vd->vd_Month = tmp;
2602 buffer += pos;
2603 if (*buffer++ == '.')
2604 {
2605 if( (pos = StrToLong((STRPTR) buffer, &tmp)) != -1 )
2606 {
2607 if( (tmp >= 70) && (tmp <= 99) )
2608 {
2609 tmp += 1900;
2610 }
2611 if( (tmp < 70) )
2612 {
2613 tmp += 2000;
2614 }
2615 vd->vd_Year = tmp;
2616 }
2617 }
2618 }
2619 }
2620 }
2621 }
2622 }
2623 }
2624 }
2625 }
2626 }
2627 }
2628
2629 /* Return a pointer to a string, stripped by all leading space characters
2630 * (SPACE).
2631 */
2632 static
2633 STRPTR skipspaces( STRPTR buffer)
2634 {
2635 for (;; buffer++)
2636 {
2637 if (buffer[0] == '\0' || buffer[0] != ' ')
2638 {
2639 return( buffer );
2640 }
2641 }
2642 }
2643
2644 /* Return a pointer to a string, stripped by all non space characters
2645 * (SPACE).
2646 */
2647 static
2648 STRPTR skipnonspaces( STRPTR buffer)
2649 {
2650 for (;; buffer++)
2651 {
2652 if (buffer[0] == '\0' || buffer[0] == ' ')
2653 {
2654 return( buffer );
2655 }
2656 }
2657 }
Mirror of AROS' svn.