rom/dos/rename.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Rename a file
   6     Lang: english
   7 */
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10 #include <proto/exec.h>
  11 #include "dos_intern.h"
  12 #include <string.h>
  13
  14 /*****************************************************************************
  15
  16     NAME */
  17 #include <exec/types.h>
  18 #include <proto/dos.h>
  19
  20         AROS_LH2(LONG, Rename,
  21
  22 /*  SYNOPSIS */
  23         AROS_LHA(CONST_STRPTR, oldName, D1),
  24         AROS_LHA(CONST_STRPTR, newName, D2),
  25
  26 /*  LOCATION */
  27         struct DosLibrary *, DOSBase, 13, Dos)
  28
  29 /*  FUNCTION
  30         Renames a given file. The old name and the new name must point to the
  31         same volume.
  32
  33     INPUTS
  34         oldName - Name of the file to rename
  35         newName - New name of the file to rename
  36
  37     RESULT
  38         boolean - DOSTRUE or DOSFALSE. IoErr() provides additional information
  39         on DOSFALSE.
  40
  41     NOTES
  42
  43     EXAMPLE
  44
  45     BUGS
  46
  47     SEE ALSO
  48
  49     INTERNALS
  50         Calls the action FSA_RENAME on the filesystem-handler.
  51
  52 *****************************************************************************/
  53 {
  54     AROS_LIBFUNC_INIT
  55     struct DevProc *olddvp, *newdvp;
  56     struct IOFileSys iofs;
  57     LONG err;
  58     struct Process *me = (struct Process *)FindTask(NULL);
  59     char buf1[256], vol[32];
  60     char buf2[256];
  61     int len;
  62
  63     InitIOFS(&iofs, FSA_RENAME, DOSBase);
  64
  65     len = SplitName(oldName, ':', vol, 0, sizeof(vol) - 1);
  66
  67     if (len > 0)
  68     {
  69         /* get real name */
  70         BPTR lock = Lock(oldName, SHARED_LOCK);
  71         if (lock)
  72         {
  73             if (NameFromLock(lock, buf1, sizeof(buf1) - 1))
  74                 oldName = buf1;
  75             UnLock(lock);
  76         }
  77     }
  78     else
  79     {
  80         /* convert to absolute path */
  81         if (NameFromLock(me->pr_CurrentDir, buf1, sizeof(buf1) - 1))
  82         {
  83             int namelen = strlen(oldName);
  84             len = strlen(buf1);
  85             if (len + namelen < sizeof(buf1) - 1)
  86             {
  87                 if (buf1[len - 1] != ':')
  88                     buf1[len++] = '/';
  89                 CopyMem(oldName, buf1 + len, namelen + 1);
  90                 oldName = buf1;
  91             }
  92         }
  93     }
  94
  95     len = SplitName(newName, ':', vol, 0, sizeof(vol) - 1);
  96
  97     if (len > 0)
  98     {
  99         /* get real name of destination path */
 100         BPTR lock;
 101         char *pos;
 102         const char *pos2;
 103
 104         strcpy(buf2, newName);
 105         pos = strrchr(buf2, '/');
 106         if (!pos)
 107         {
 108             pos = buf2 + len;
 109             *pos = '\0';
 110         }
 111         else
 112             *pos++ = '\0';
 113
 114         lock = Lock(buf2, SHARED_LOCK);
 115         if (lock)
 116         {
 117             if (NameFromLock(lock, buf2, sizeof(buf2) - 1))
 118             {
 119                 int namelen;
 120                 len = strlen(buf2);
 121                 pos2 = newName + (int)(pos - buf2);
 122                 namelen = strlen(pos2);
 123                 if (len + namelen < sizeof(buf2) - 1)
 124                 {
 125                     if (buf2[len - 1] != ':')
 126                         buf2[len++] = '/';
 127                     CopyMem(pos2, buf2 + len, namelen + 1);
 128                     newName = buf2;
 129                 }
 130             }
 131         }
 132     }
 133     else
 134     {
 135         /* convert to absolute path */
 136         if (NameFromLock(me->pr_CurrentDir, buf2, sizeof(buf2) - 1))
 137         {
 138             int namelen = strlen(newName);
 139             len = strlen(buf2);
 140             if (len + namelen < sizeof(buf2) - 1)
 141             {
 142                 if (buf2[len - 1] != ':')
 143                     buf2[len++] = '/';
 144                 CopyMem(newName, buf2 + len, namelen + 1);
 145                 newName = buf2;
 146             }
 147         }
 148     }
 149
 150     D(bug("[Dos] rename %s %s\n", oldName, newName));
 151
 152     /* get device pointers */
 153     if ((olddvp = GetDeviceProc(oldName, NULL)) == NULL ||
 154         (newdvp = GetDeviceProc(newName, NULL)) == NULL) {
 155         FreeDeviceProc(olddvp);
 156         return DOSFALSE;
 157     }
 158
 159     /* make sure they're on the same device
 160      * XXX this is insufficient, see comments in samedevice.c */
 161     if (olddvp->dvp_Port != newdvp->dvp_Port) {
 162         FreeDeviceProc(olddvp);
 163         FreeDeviceProc(newdvp);
 164         SetIoErr(ERROR_RENAME_ACROSS_DEVICES);
 165         return DOSFALSE;
 166     }
 167
 168     iofs.io_Union.io_RENAME.io_NewName = StripVolume(newName);
 169     err = DoIOFS(&iofs, olddvp, oldName, DOSBase);
 170
 171     FreeDeviceProc(olddvp);
 172     FreeDeviceProc(newdvp);
 173
 174     return err == 0 ? DOSTRUE : DOSFALSE;
 175
 176     AROS_LIBFUNC_EXIT
 177 } /* Rename */