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