workbench/c/Rename.c

   1 /*
   2     Copyright © 1995-2004, 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         Workbench/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 <stdio.h>
  87 #include <string.h>
  88
  89 #define ARG_TEMPLATE    "FROM/A/M,TO=AS/A,QUIET/S"
  90
  91 #define APPNAME         "Rename"
  92
  93 enum
  94 {
  95     ARG_FROM = 0,
  96     ARG_TO,
  97     ARG_QUIET,
  98     NOOFARGS
  99 };
 100
 101
 102 #define MAX_PATH_LEN    2048
 103
 104 static const char version[] = "$VER: Rename 41.2 (23.11.2000)\n";
 105
 106
 107 int doRename(STRPTR *from, STRPTR to, BOOL quiet);
 108
 109
 110 int __nocommandline;
 111
 112 int main(void)
 113 {
 114     struct RDArgs     *rda;
 115
 116     IPTR  args[NOOFARGS] = { (IPTR) NULL, (IPTR) NULL, FALSE };
 117
 118     int   retval = RETURN_FAIL;
 119
 120     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 121
 122     if(rda != NULL)
 123     {
 124         STRPTR *from  = (STRPTR *)args[ARG_FROM];
 125         STRPTR  to    = (STRPTR)args[ARG_TO];
 126         BOOL    quiet = (BOOL)args[ARG_QUIET];
 127
 128         retval = doRename(from, to, quiet);
 129
 130         FreeArgs(rda);
 131     }
 132     else
 133     {
 134         PrintFault(IoErr(), APPNAME);
 135         retval = RETURN_ERROR;
 136     }
 137
 138     return retval;
 139 }
 140
 141
 142 int doRename(STRPTR *from, STRPTR to, BOOL quiet)
 143 {
 144 #define ERROR(n) retval = (n); goto cleanup
 145
 146         struct AnchorPath *ap;
 147
 148         UBYTE   *pathName;
 149         STRPTR  fileStart;
 150         BOOL    destIsDir = FALSE;
 151         BOOL    destExists = FALSE;
 152         LONG    match;
 153         BPTR    tolock = NULL;
 154         ULONG   i;
 155         int     retval;
 156         LONG    ioerr = 0;
 157         UBYTE   itsWild;
 158         BOOL    isSingle;
 159
 160         ap = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN + MAX_PATH_LEN,
 161                                            MEMF_ANY | MEMF_CLEAR);
 162         if (!ap)
 163         {
 164                 ioerr = IoErr();
 165                 ERROR(RETURN_FAIL);
 166         }
 167
 168         pathName = ((UBYTE *) (ap + 1)) + MAX_PATH_LEN;
 169
 170         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 171         ap->ap_Flags     = APF_DOWILD;
 172         ap->ap_Strlen    = MAX_PATH_LEN;
 173         if (MatchFirst(from[0], ap) != 0)
 174         {
 175                 ioerr = IoErr();
 176                 if (ioerr == ERROR_OBJECT_NOT_FOUND)
 177                 {
 178                         Printf("Can't rename %s as %s because ", (ULONG)from[0], (ULONG)to);
 179                 }
 180                 ERROR(RETURN_FAIL);
 181         }
 182         itsWild = ap->ap_Flags & APF_ITSWILD;
 183         MatchEnd(ap);
 184
 185         /* First we check if the destination is a directory */
 186         tolock = Lock(to, SHARED_LOCK);
 187         if (tolock)
 188         {
 189                 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 190                 LONG entrytype;
 191
 192                 destExists = TRUE;
 193
 194                 if (!fib)
 195                 {
 196                         PrintFault(IoErr(), APPNAME);
 197
 198                         ERROR(RETURN_FAIL);
 199                 }
 200
 201                 i = Examine(tolock, fib);
 202                 entrytype = fib->fib_EntryType;
 203                 FreeDosObject(DOS_FIB, fib);
 204
 205                 if (i)
 206                 {
 207                         if (entrytype >= 0)
 208                         {
 209                                 destIsDir = TRUE;
 210                         }
 211                 }
 212                 else
 213                 {
 214                         PrintFault(IoErr(), APPNAME);
 215
 216                         ERROR(RETURN_FAIL);
 217                 }
 218         }
 219
 220
 221         /* Check if dest is not a dir and src is pattern or multi */
 222         if (!destIsDir && (itsWild || from[1]))
 223         {
 224                 Printf("Destination \"%s\" is not a directory.\n", (ULONG)to);
 225                 ERROR(RETURN_FAIL);
 226         }
 227
 228
 229         /* Handle single file name change */
 230         isSingle =!destIsDir;
 231         /* 15th Jan 2004 bugfix, (destIsDir && ...) not (!destisDir && ...) ! - Piru */
 232         if (destIsDir && !from[1])
 233         {
 234                 BPTR fromlock;
 235
 236                 fromlock = Lock(from[0], ACCESS_READ);
 237                 if (fromlock)
 238                 {
 239                         isSingle = SameLock(fromlock, tolock) == LOCK_SAME;
 240
 241                         UnLock(fromlock);
 242                 }
 243
 244                 /* 4th May 2003 bugfix: be quiet about single object renames - Piru */
 245                 quiet = TRUE;
 246         }
 247         if (isSingle)
 248         {
 249                 if (ParsePattern(from[0], pathName, MAX_PATH_LEN) > -1 &&
 250                     Rename(pathName, to))
 251                 {
 252                         ERROR(RETURN_OK);
 253                 }
 254
 255                 ioerr = IoErr();
 256                 Printf("Can't rename %s as %s because ", (ULONG)from[0], (ULONG)to);
 257                 ERROR(RETURN_FAIL);
 258         }
 259
 260         if (tolock)
 261         {
 262                 if (!NameFromLock(tolock, pathName, MAX_PATH_LEN))
 263                 {
 264                         if (IoErr() == ERROR_LINE_TOO_LONG)
 265                         {
 266                                 PrintFault(IoErr(), APPNAME);
 267
 268                                 ERROR(RETURN_FAIL);
 269                         }
 270
 271                         pathName[0] = '\0';
 272                 }
 273         }
 274
 275         if (!pathName[0])
 276         {
 277                 stccpy(pathName, to, MAX_PATH_LEN);
 278         }
 279
 280
 281         /* Now either only one specific file should be renamed or the
 282            destination is really a directory. We can use the same routine
 283            for both cases! */
 284
 285         fileStart = pathName + strlen(pathName);
 286
 287         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 288         ap->ap_Strlen    = MAX_PATH_LEN;
 289
 290         for (i = 0; from[i]; i++)
 291         {
 292                 for (match = MatchFirst(from[i], ap); match == 0; match = MatchNext(ap))
 293                 {
 294                         /* Check for identical 'from' and 'to'? */
 295
 296                         if (destIsDir)
 297                         {
 298                                 /* Clear former filename */
 299                                 *fileStart = '\0';
 300                                 if (!AddPart(pathName, FilePart(ap->ap_Buf), MAX_PATH_LEN))
 301                                 {
 302                                         MatchEnd(ap);
 303
 304                                         PrintFault(ERROR_LINE_TOO_LONG, APPNAME);
 305                                         SetIoErr(ERROR_LINE_TOO_LONG);
 306
 307                                         ERROR(RETURN_FAIL);
 308                                 }
 309                         }
 310
 311                         if (!quiet)
 312                         {
 313                                 Printf("Renaming %s as %s\n", (ULONG)ap->ap_Buf, (ULONG)pathName);
 314                         }
 315
 316                         if (!Rename(ap->ap_Buf, pathName))
 317                         {
 318                                 ioerr = IoErr();
 319                                 MatchEnd(ap);
 320
 321                                 Printf("Can't rename %s as %s because ", (ULONG)ap->ap_Buf, (ULONG)pathName);
 322                                 ERROR(RETURN_FAIL);
 323                         }
 324                 }
 325
 326                 MatchEnd(ap);
 327         }
 328
 329         if (ap->ap_FoundBreak & SIGBREAKF_CTRL_C)
 330         {
 331                 PrintFault(ERROR_BREAK, NULL);
 332
 333                 retval = RETURN_WARN;
 334         }
 335         else
 336         {
 337                 retval = RETURN_OK;
 338         }
 339
 340 cleanup:
 341         if (tolock)
 342         {
 343                 UnLock(tolock);
 344         }
 345
 346         if (ioerr)
 347         {
 348                 //MatchEnd(ap);
 349                 PrintFault(ioerr, NULL);
 350                 SetIoErr(ioerr);
 351                 //retval = ERROR_FAIL;
 352         }
 353
 354         FreeVec(ap);
 355
 356         return retval;
 357 }