home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / emu / AROSdev.lha / AROS / workbench / c / copy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-27  |  3.5 KB  |  214 lines
  1. /*
  2.     (C) 1995-96 AROS - The Amiga Replacement OS
  3.     $Id: copy.c,v 1.3 1997/01/27 00:22:36 ldp Exp $
  4.  
  5.     Desc: Copy CLI command
  6.     Lang: english
  7. */
  8. #include <exec/memory.h>
  9. #include <proto/exec.h>
  10. #include <dos/dos.h>
  11. #include <dos/exall.h>
  12. #include <dos/datetime.h>
  13. #include <proto/dos.h>
  14. #include <proto/utility.h>
  15. #include <utility/tagitem.h>
  16. #include <utility/utility.h>
  17. /* #include <proto/aros.h> */
  18. #include <string.h>
  19.  
  20. static const char version[] = "$VER: Copy 1.0 (4.10.1996)\n";
  21.  
  22. UBYTE Buffer[4096];
  23. APTR mem;
  24. ULONG size;
  25.  
  26. int CopyFile (UBYTE * src, UBYTE * dest)
  27. {
  28.     BPTR file_in, file_out;
  29.     IPTR pargs[5];
  30.     int ret = TRUE;
  31.     LONG read_size;
  32.  
  33.     file_in = file_out = (BPTR)NULL;
  34.  
  35.     file_in = Open (src, MODE_OLDFILE);
  36.  
  37.     if (!file_in)
  38.     {
  39.     pargs[0] = (IPTR)src;
  40.     VPrintf ("Cannot open file %s for reading: ", pargs);
  41.     PrintFault (IoErr (), "");
  42.     goto error_exit;
  43.     }
  44.  
  45.     file_out = Open (dest, MODE_NEWFILE);
  46.  
  47.     if (!file_out)
  48.     {
  49.     pargs[0] = (IPTR)dest;
  50.     VPrintf ("Cannot open file %s for writing: ", pargs);
  51.     PrintFault (IoErr (), "");
  52.     goto error_exit;
  53.     }
  54.  
  55.     pargs[0] = (IPTR)src;
  56.  
  57.     VPrintf ("    %s", pargs);
  58.     Flush (Output ());
  59.  
  60.     while ((read_size = Read (file_in, mem, size)) > 0)
  61.     Write (file_out, mem, size);
  62.  
  63.     VPrintf ("...\n", NULL);
  64.  
  65.     goto ok_exit;
  66.  
  67. error_exit:
  68.     ret = FALSE;
  69.  
  70. ok_exit:
  71.     if (file_in)
  72.     Close (file_in);
  73.  
  74.     if (file_out)
  75.     Close (file_out);
  76.  
  77.     return ret;
  78. }
  79.  
  80. int main (int argc, char ** argv)
  81. {
  82.     IPTR args[3];
  83. #define ARG_Source    ((UBYTE **)args[0])
  84. #define ARG_Dest    ((UBYTE *)args[1])
  85.     struct RDArgs *rda;
  86.     LONG error=0;
  87.     IPTR pargs[5];
  88.     struct FileInfoBlock * fib;
  89.     BPTR lock;
  90.  
  91.     fib = NULL;
  92.     mem = NULL;
  93.     lock = (BPTR)NULL;
  94.  
  95.     rda = ReadArgs ("Source/M/A,Dest/A", (IPTR *)&args, NULL);
  96.  
  97.     if (rda != NULL)
  98.     {
  99.     LONG t;
  100.     BOOL DestIsDir;
  101.  
  102.     fib = AllocMem (sizeof (struct FileInfoBlock), MEMF_ANY);
  103.  
  104.     if (!fib)
  105.     {
  106.         VPrintf ("Not enough memory\n", NULL);
  107.         goto error_exit;
  108.     }
  109.  
  110.     for (size=0x10000L; size; size >>= 1)
  111.         if ((mem = AllocMem (size, MEMF_ANY)))
  112.         break;
  113.  
  114.     if (!size)
  115.     {
  116.         VPrintf ("Not enough memory\n", NULL);
  117.         goto error_exit;
  118.     }
  119.  
  120.     DestIsDir = FALSE;
  121.  
  122.     lock = Lock (ARG_Dest, SHARED_LOCK);
  123.  
  124.     if (!lock)
  125.     {
  126.         if (IoErr() != ERROR_OBJECT_NOT_FOUND)
  127.         {
  128.         pargs[0] = (IPTR)ARG_Dest;
  129.         VPrintf ("Cannot lock %s: ", pargs);
  130.         PrintFault (IoErr (), "");
  131.         goto error_exit;
  132.         }
  133.     }
  134.     else
  135.     {
  136.         Examine (lock, fib);
  137.  
  138.         UnLock (lock);
  139.         lock = (BPTR)NULL;
  140.  
  141.         if (fib->fib_DirEntryType > 0) /* Directory ? */
  142.         DestIsDir = TRUE;
  143.     }
  144.  
  145.     if (!DestIsDir)
  146.     {
  147.         if (ARG_Source[1])
  148.         {
  149.         VPrintf ("Destination is not a directory\n", NULL);
  150.         goto error_exit;
  151.         }
  152.         else
  153.         {
  154.         if (!CopyFile (ARG_Source[0], ARG_Dest))
  155.             goto error_exit;
  156.         }
  157.     }
  158.     else
  159.     {
  160.         UBYTE * ptr;
  161.  
  162.         strcpy (Buffer, ARG_Dest);
  163.  
  164.         if (*Buffer)
  165.         {
  166.         ptr = Buffer + strlen (Buffer) - 1;
  167.  
  168.         if (*ptr == ':' || *ptr == '/')
  169.             ptr ++;
  170.         else
  171.         {
  172.             ptr ++;
  173.             *ptr ++ = '/';
  174.         }
  175.         }
  176.         else
  177.         ptr = Buffer;
  178.  
  179.         for (t=0; ARG_Source[t]; t++)
  180.         {
  181.         strcpy (ptr, ARG_Source[t]);
  182.  
  183.         if (!CopyFile (ARG_Source[0], ARG_Dest))
  184.             goto error_exit;
  185.         }
  186.     }
  187.  
  188.     FreeArgs (rda);
  189.     }
  190.     else
  191.     {
  192.     PrintFault (IoErr (), "Copy");
  193.     goto error_exit;
  194.     }
  195.  
  196.     goto ok_exit;
  197.  
  198. error_exit:
  199.     error = RETURN_ERROR;
  200.  
  201. ok_exit:
  202.     if (lock)
  203.     UnLock (lock);
  204.  
  205.     if (mem)
  206.     FreeMem (mem, size);
  207.  
  208.     if (fib)
  209.     FreeMem (fib, sizeof (struct FileInfoBlock));
  210.  
  211.     return error;
  212. }
  213.  
  214.