workbench/c/Rename.c

   1 /*
   2     Copyright © 1995-2014, 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.3 (3.4.2014)\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                 ioerr = IoErr();
 199                 entrytype = fib->fib_EntryType;
 200                 FreeDosObject(DOS_FIB, fib);
 201
 202                 if (i)
 203                 {
 204                         ioerr = 0;
 205                         if (entrytype >= 0)
 206                         {
 207                                 destIsDir = TRUE;
 208                         }
 209                 }
 210                 else
 211                 {
 212                         PrintFault(ioerr, APPNAME);
 213                         ioerr = 0;
 214
 215                         ERROR(RETURN_FAIL);
 216                 }
 217         }
 218
 219
 220         /* Check if dest is not a dir and src is pattern or multi */
 221         if (!destIsDir && (itsWild || from[1]))
 222         {
 223                 Printf("Destination \"%s\" is not a directory.\n", to);
 224                 ERROR(RETURN_FAIL);
 225         }
 226
 227
 228         /* Handle single file name change */
 229         isSingle =!destIsDir;
 230         /* 15th Jan 2004 bugfix, (destIsDir && ...) not (!destisDir && ...) ! - Piru */
 231         if (destIsDir && !from[1])
 232         {
 233                 BPTR fromlock;
 234
 235                 fromlock = Lock(from[0], ACCESS_READ);
 236                 if (fromlock)
 237                 {
 238                         isSingle = SameLock(fromlock, tolock) == LOCK_SAME;
 239
 240                         UnLock(fromlock);
 241                 }
 242
 243                 /* 4th May 2003 bugfix: be quiet about single object renames - Piru */
 244                 quiet = TRUE;
 245         }
 246         if (isSingle)
 247         {
 248                 if (ParsePattern(from[0], pathName, MAX_PATH_LEN) > -1 &&
 249                     Rename(pathName, to))
 250                 {
 251                         ERROR(RETURN_OK);
 252                 }
 253
 254                 ioerr = IoErr();
 255                 Printf("Can't rename %s as %s because ", from[0], to);
 256                 ERROR(RETURN_FAIL);
 257         }
 258
 259         if (tolock)
 260         {
 261                 if (!NameFromLock(tolock, pathName, MAX_PATH_LEN))
 262                 {
 263                         if (IoErr() == ERROR_LINE_TOO_LONG)
 264                         {
 265                                 PrintFault(IoErr(), APPNAME);
 266
 267                                 ERROR(RETURN_FAIL);
 268                         }
 269
 270                         pathName[0] = '\0';
 271                 }
 272         }
 273
 274         if (!pathName[0])
 275         {
 276                 stccpy(pathName, to, MAX_PATH_LEN);
 277         }
 278
 279
 280         /* Now either only one specific file should be renamed or the
 281            destination is really a directory. We can use the same routine
 282            for both cases! */
 283
 284         fileStart = pathName + strlen(pathName);
 285
 286         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 287         ap->ap_Strlen    = MAX_PATH_LEN;
 288
 289         for (i = 0; from[i]; i++)
 290         {
 291                 for (match = MatchFirst(from[i], ap); match == 0; match = MatchNext(ap))
 292                 {
 293                         /* Check for identical 'from' and 'to'? */
 294
 295                         if (destIsDir)
 296                         {
 297                                 /* Clear former filename */
 298                                 *fileStart = '\0';
 299                                 if (!AddPart(pathName, FilePart(ap->ap_Buf), MAX_PATH_LEN))
 300                                 {
 301                                         MatchEnd(ap);
 302
 303                                         PrintFault(ERROR_LINE_TOO_LONG, APPNAME);
 304                                         SetIoErr(ERROR_LINE_TOO_LONG);
 305
 306                                         ERROR(RETURN_FAIL);
 307                                 }
 308                         }
 309
 310                         if (!quiet)
 311                         {
 312                                 Printf("Renaming %s as %s\n", ap->ap_Buf, pathName);
 313                         }
 314
 315                         if (!Rename(ap->ap_Buf, pathName))
 316                         {
 317                                 ioerr = IoErr();
 318                                 MatchEnd(ap);
 319
 320                                 Printf("Can't rename %s as %s because ", ap->ap_Buf, pathName);
 321                                 ERROR(RETURN_FAIL);
 322                         }
 323                 }
 324
 325                 MatchEnd(ap);
 326         }
 327
 328         if (ap->ap_FoundBreak & SIGBREAKF_CTRL_C)
 329         {
 330                 PrintFault(ERROR_BREAK, NULL);
 331
 332                 retval = RETURN_WARN;
 333         }
 334         else
 335         {
 336                 retval = RETURN_OK;
 337         }
 338
 339 cleanup:
 340         if (tolock)
 341         {
 342                 UnLock(tolock);
 343         }
 344
 345         if (ioerr)
 346         {
 347                 //MatchEnd(ap);
 348                 PrintFault(ioerr, NULL);
 349                 //retval = ERROR_FAIL;
 350         }
 351
 352         FreeVec(ap);
 353
 354         return retval;
 355 }