workbench/c/Rename.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Rename CLI command.
   6 */
   7
   8 /*****************************************************************************
   9
  10     NAME
  11
  12         Rename
  13
  14     SYNOPSIS
  15
  16         Rename [{FROM}] <name> [TO|AS] <name> [QUIET]
  17
  18         FROM/A/M,TO=AS/A,QUIET/S
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         Renames a directory or file. Rename can also act like the UNIX mv
  27         command, which moves a file or files to another location on disk.
  28
  29     INPUTS
  30
  31         FROM   --  The name(s) of the file(s) to rename or move. There may
  32                    be many files specified, this is used when moving files
  33                    into a new directory.
  34
  35         TO|AS  --  The name which we wish to call the file.
  36
  37         QUIET  --  Suppress any output from the command.
  38
  39     RESULT
  40
  41         Standard DOS error codes.
  42
  43     NOTES
  44
  45     EXAMPLE
  46
  47         Rename letter1.doc letter2.doc letters
  48
  49             Moves letter1.doc and letter2.doc to the directory letters.
  50
  51         Rename ram:a ram:b quiet
  52         Rename from ram:a to ram:b quiet
  53         Rename from=ram:a to=ram:b quiet
  54
  55             All versions, renames file "a" to "b" and does not output any
  56             diagnostic information.
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64         Rename() can only move a file to another directory, if and only if
  65         the to path has the from filename appended to the end.
  66
  67         e.g.
  68             Rename("ram:a", "ram:clipboards/a");
  69         not
  70             Rename("ram:a", "ram:clipboards/");
  71
  72 ******************************************************************************/
  73
  74 #define  DEBUG  0
  75 #include <aros/debug.h>
  76
  77 #include <proto/dos.h>
  78 #include <proto/exec.h>
  79
  80 #include <dos/dos.h>
  81 #include <dos/dosasl.h>
  82 #include <dos/rdargs.h>
  83 #include <exec/memory.h>
  84 #include <exec/types.h>
  85
  86 #include <string.h>
  87
  88 #define ARG_TEMPLATE    "FROM/A/M,TO=AS/A,QUIET/S"
  89
  90 #define APPNAME         "Rename"
  91
  92 enum
  93 {
  94     ARG_FROM,
  95     ARG_TO,
  96     ARG_QUIET,
  97     NOOFARGS
  98 };
  99
 100
 101 #define MAX_PATH_LEN    2048
 102
 103 const TEXT version[] = "$VER: Rename 41.2 (23.11.2000)\n";
 104
 105
 106 int doRename(STRPTR *from, STRPTR to, BOOL quiet);
 107
 108
 109 int __nocommandline;
 110
 111 int main(void)
 112 {
 113     struct RDArgs     *rda;
 114
 115     IPTR  args[NOOFARGS] = { (IPTR) NULL, (IPTR) NULL, FALSE };
 116
 117     int   retval = RETURN_FAIL;
 118
 119     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 120
 121     if(rda != NULL)
 122     {
 123         STRPTR *from  = (STRPTR *)args[ARG_FROM];
 124         STRPTR  to    = (STRPTR)args[ARG_TO];
 125         BOOL    quiet = args[ARG_QUIET] != 0;
 126
 127         retval = doRename(from, to, quiet);
 128
 129         FreeArgs(rda);
 130     }
 131     else
 132     {
 133         PrintFault(IoErr(), APPNAME);
 134         retval = RETURN_ERROR;
 135     }
 136
 137     return retval;
 138 }
 139
 140
 141 int doRename(STRPTR *from, STRPTR to, BOOL quiet)
 142 {
 143 #define ERROR(n) retval = (n); goto cleanup
 144
 145         struct AnchorPath *ap;
 146
 147         UBYTE   *pathName;
 148         STRPTR  fileStart;
 149         BOOL    destIsDir = FALSE;
 150         LONG    match;
 151         BPTR    tolock = BNULL;
 152         ULONG   i;
 153         int     retval;
 154         LONG    ioerr = 0;
 155         UBYTE   itsWild;
 156         BOOL    isSingle;
 157
 158         ap = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN + MAX_PATH_LEN,
 159                                            MEMF_ANY | MEMF_CLEAR);
 160         if (!ap)
 161         {
 162                 ioerr = IoErr();
 163                 ERROR(RETURN_FAIL);
 164         }
 165
 166         pathName = ((UBYTE *) (ap + 1)) + MAX_PATH_LEN;
 167
 168         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 169         ap->ap_Flags     = APF_DOWILD;
 170         ap->ap_Strlen    = MAX_PATH_LEN;
 171         if (MatchFirst(from[0], ap) != 0)
 172         {
 173                 ioerr = IoErr();
 174                 if (ioerr == ERROR_OBJECT_NOT_FOUND)
 175                 {
 176                         Printf("Can't rename %s as %s because ", from[0], to);
 177                 }
 178                 ERROR(RETURN_FAIL);
 179         }
 180         itsWild = ap->ap_Flags & APF_ITSWILD;
 181         MatchEnd(ap);
 182
 183         /* First we check if the destination is a directory */
 184         tolock = Lock(to, SHARED_LOCK);
 185         if (tolock)
 186         {
 187                 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 188                 LONG entrytype;
 189
 190                 if (!fib)
 191                 {
 192                         PrintFault(IoErr(), APPNAME);
 193
 194                         ERROR(RETURN_FAIL);
 195                 }
 196
 197                 i = Examine(tolock, fib);
 198                 entrytype = fib->fib_EntryType;
 199                 FreeDosObject(DOS_FIB, fib);
 200
 201                 if (i)
 202                 {
 203                         if (entrytype >= 0)
 204                         {
 205                                 destIsDir = TRUE;
 206                         }
 207                 }
 208                 else
 209                 {
 210                         PrintFault(IoErr(), APPNAME);
 211
 212                         ERROR(RETURN_FAIL);
 213                 }
 214         }
 215
 216
 217         /* Check if dest is not a dir and src is pattern or multi */
 218         if (!destIsDir && (itsWild || from[1]))
 219         {
 220                 Printf("Destination \"%s\" is not a directory.\n", to);
 221                 ERROR(RETURN_FAIL);
 222         }
 223
 224
 225         /* Handle single file name change */
 226         isSingle =!destIsDir;
 227         /* 15th Jan 2004 bugfix, (destIsDir && ...) not (!destisDir && ...) ! - Piru */
 228         if (destIsDir && !from[1])
 229         {
 230                 BPTR fromlock;
 231
 232                 fromlock = Lock(from[0], ACCESS_READ);
 233                 if (fromlock)
 234                 {
 235                         isSingle = SameLock(fromlock, tolock) == LOCK_SAME;
 236
 237                         UnLock(fromlock);
 238                 }
 239
 240                 /* 4th May 2003 bugfix: be quiet about single object renames - Piru */
 241                 quiet = TRUE;
 242         }
 243         if (isSingle)
 244         {
 245                 if (ParsePattern(from[0], pathName, MAX_PATH_LEN) > -1 &&
 246                     Rename(pathName, to))
 247                 {
 248                         ERROR(RETURN_OK);
 249                 }
 250
 251                 ioerr = IoErr();
 252                 Printf("Can't rename %s as %s because ", from[0], to);
 253                 ERROR(RETURN_FAIL);
 254         }
 255
 256         if (tolock)
 257         {
 258                 if (!NameFromLock(tolock, pathName, MAX_PATH_LEN))
 259                 {
 260                         if (IoErr() == ERROR_LINE_TOO_LONG)
 261                         {
 262                                 PrintFault(IoErr(), APPNAME);
 263
 264                                 ERROR(RETURN_FAIL);
 265                         }
 266
 267                         pathName[0] = '\0';
 268                 }
 269         }
 270
 271         if (!pathName[0])
 272         {
 273                 stccpy(pathName, to, MAX_PATH_LEN);
 274         }
 275
 276
 277         /* Now either only one specific file should be renamed or the
 278            destination is really a directory. We can use the same routine
 279            for both cases! */
 280
 281         fileStart = pathName + strlen(pathName);
 282
 283         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 284         ap->ap_Strlen    = MAX_PATH_LEN;
 285
 286         for (i = 0; from[i]; i++)
 287         {
 288                 for (match = MatchFirst(from[i], ap); match == 0; match = MatchNext(ap))
 289                 {
 290                         /* Check for identical 'from' and 'to'? */
 291
 292                         if (destIsDir)
 293                         {
 294                                 /* Clear former filename */
 295                                 *fileStart = '\0';
 296                                 if (!AddPart(pathName, FilePart(ap->ap_Buf), MAX_PATH_LEN))
 297                                 {
 298                                         MatchEnd(ap);
 299
 300                                         PrintFault(ERROR_LINE_TOO_LONG, APPNAME);
 301                                         SetIoErr(ERROR_LINE_TOO_LONG);
 302
 303                                         ERROR(RETURN_FAIL);
 304                                 }
 305                         }
 306
 307                         if (!quiet)
 308                         {
 309                                 Printf("Renaming %s as %s\n", ap->ap_Buf, pathName);
 310                         }
 311
 312                         if (!Rename(ap->ap_Buf, pathName))
 313                         {
 314                                 ioerr = IoErr();
 315                                 MatchEnd(ap);
 316
 317                                 Printf("Can't rename %s as %s because ", ap->ap_Buf, pathName);
 318                                 ERROR(RETURN_FAIL);
 319                         }
 320                 }
 321
 322                 MatchEnd(ap);
 323         }
 324
 325         if (ap->ap_FoundBreak & SIGBREAKF_CTRL_C)
 326         {
 327                 PrintFault(ERROR_BREAK, NULL);
 328
 329                 retval = RETURN_WARN;
 330         }
 331         else
 332         {
 333                 retval = RETURN_OK;
 334         }
 335
 336 cleanup:
 337         if (tolock)
 338         {
 339                 UnLock(tolock);
 340         }
 341
 342         if (ioerr)
 343         {
 344                 //MatchEnd(ap);
 345                 PrintFault(ioerr, NULL);
 346                 SetIoErr(ioerr);
 347                 //retval = ERROR_FAIL;
 348         }
 349
 350         FreeVec(ap);
 351
 352         return retval;
 353 }