rom/dos/rename.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Rename a file
   6     Lang: english
   7 */
   8
   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
  51 *****************************************************************************/
  52 {
  53     AROS_LIBFUNC_INIT
  54
  55     struct DevProc *olddvp, *newdvp;
  56     LONG status;
  57     struct Process *me = (struct Process *)FindTask(NULL);
  58     char buf1[256], vol[32];
  59     char buf2[256];
  60     int len;
  61     BSTR bstrNewName, bstrOldName;
  62
  63     ASSERT_VALID_PROCESS(me);
  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'; /* Keep slashes in name, to support a/b//c => a/c case */
 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             UnLock(lock);
 132         }
 133     }
 134     else
 135     {
 136         /* convert to absolute path */
 137         if (NameFromLock(me->pr_CurrentDir, buf2, sizeof(buf2) - 1))
 138         {
 139             int namelen = strlen(newName);
 140             len = strlen(buf2);
 141             if (len + namelen < sizeof(buf2) - 1)
 142             {
 143                 if (buf2[len - 1] != ':')
 144                     buf2[len++] = '/';
 145                 CopyMem(newName, buf2 + len, namelen + 1);
 146                 newName = buf2;
 147             }
 148         }
 149     }
 150
 151     D(bug("[Dos] rename %s %s\n", oldName, newName));
 152
 153     /* get device pointers */
 154     if ((olddvp = GetDeviceProc(oldName, NULL)) == NULL ||
 155         (newdvp = GetDeviceProc(newName, NULL)) == NULL) {
 156         FreeDeviceProc(olddvp);
 157         return DOSFALSE;
 158     }
 159
 160     /* make sure they're on the same device
 161      * XXX this is insufficient, see comments in samedevice.c */
 162     if (olddvp->dvp_Port != newdvp->dvp_Port) {
 163         FreeDeviceProc(olddvp);
 164         FreeDeviceProc(newdvp);
 165         SetIoErr(ERROR_RENAME_ACROSS_DEVICES);
 166         return DOSFALSE;
 167     }
 168
 169     bstrNewName = C2BSTR(newName);
 170     bstrOldName = C2BSTR(oldName);
 171     status = dopacket4(DOSBase, NULL, olddvp->dvp_Port, ACTION_RENAME_OBJECT, olddvp->dvp_Lock, bstrOldName, newdvp->dvp_Lock, bstrNewName);
 172     FREEC2BSTR(bstrOldName);
 173     FREEC2BSTR(bstrNewName);
 174
 175     FreeDeviceProc(olddvp);
 176     FreeDeviceProc(newdvp);
 177
 178     return status;
 179
 180     AROS_LIBFUNC_EXIT
 181 } /* Rename */