workbench/c/Delete.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Delete CLI Command.
   6 */
   7
   8 /*****************************************************************************
   9
  10     NAME
  11
  12     Delete
  13
  14     SYNOPSIS
  15
  16     Delete { (name | pattern) } [ALL] [QUIET] [FORCE]
  17
  18     LOCATION
  19
  20         C:
  21
  22     FUNCTION
  23
  24     Deletes files and directories. You may delete several files and directories
  25     by listing them separately or by using wildcards. To abort a multiple
  26     delete, press CTRL-C. Delete will notify the user of which files it
  27     weren't able to delete.
  28         Delete cannot delete directories which are not empty unless the
  29     ALL option is used. To suppress file and directory names from being
  30     printed while deleted use the QUIET option. If the 'd' protection bit
  31     is cleared for a file or directory, it may not be deleted unless the
  32     FORCE option is used.
  33
  34     INPUTS
  35
  36     FILE/M/A  --  files or directories to delete (may contain patterns)
  37     ALL/S     --  recursively delete dirctories
  38     QUIET/S   --  don't print which files/directories were deleted
  39     FORCE/S   --  delete files/directories even if they are protected from
  40                   deletion
  41
  42     RESULT
  43
  44     NOTES
  45
  46     EXAMPLE
  47
  48     Delete RAM:T/#? ALL FORCE
  49
  50     Deletes all directories and files recursively in the directory RAM:T
  51     even if they are protected from deletion.
  52
  53
  54     BUGS
  55
  56     SEE ALSO
  57
  58     INTERNALS
  59
  60     Shows a good usage of the pattern matching capabilities.
  61
  62 ******************************************************************************/
  63
  64 #include <proto/dos.h>
  65 #include <proto/exec.h>
  66
  67 #include <dos/dos.h>
  68 #include <dos/dosasl.h>
  69 #include <exec/memory.h>
  70
  71 #include <string.h>
  72
  73
  74 #define ARG_TEMPLATE    "FILE/M/A,ALL/S,QUIET/S,FORCE/S,FOLLOWLINKS/S"
  75
  76 enum
  77 {
  78     ARG_FILE = 0,
  79     ARG_ALL,
  80     ARG_QUIET,
  81     ARG_FORCE,
  82     ARG_FOLLOWLINKS,
  83     NOOFARGS
  84 };
  85
  86
  87 /* Maximum file path length */
  88 #define MAX_PATH_LEN    2048
  89
  90 const TEXT version[] = "$VER: Delete 41.2 (6.1.2000)\n";
  91 static char cmdname[] = "Delete";
  92
  93
  94 int doDelete(struct AnchorPath *ap, STRPTR *files, BOOL all, BOOL quiet,
  95              BOOL force, BOOL forcelinks);
  96
  97 int __nocommandline;
  98
  99 int main(void)
 100 {
 101     struct RDArgs      *rda;
 102     struct AnchorPath  *ap;
 103     IPTR                args[NOOFARGS] = { (IPTR) NULL, FALSE, FALSE, FALSE, FALSE };
 104     int                 retval         = RETURN_OK;
 105
 106     ap = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN,
 107                   MEMF_ANY | MEMF_CLEAR);
 108
 109     if (ap != NULL)
 110     {
 111         ap->ap_Strlen = MAX_PATH_LEN;
 112
 113         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 114
 115         if (rda != NULL)
 116         {
 117             /* Convert arguments into (less complex) variables */
 118             STRPTR *files = (STRPTR *)args[ARG_FILE];
 119             BOOL    all = (BOOL)args[ARG_ALL];
 120             BOOL    quiet = (BOOL)args[ARG_QUIET];
 121             BOOL    force = (BOOL)args[ARG_FORCE];
 122             BOOL    followlinks = (BOOL)args[ARG_FOLLOWLINKS];
 123
 124             retval = doDelete(ap, files, all, quiet, force, followlinks);
 125
 126             FreeArgs(rda);
 127         }
 128         else
 129         {
 130             PrintFault(IoErr(), cmdname);
 131             retval = RETURN_FAIL;
 132         }
 133     }
 134     else
 135     {
 136         retval = RETURN_FAIL;
 137     }
 138
 139     FreeVec(ap);
 140
 141     return retval;
 142 } /* main */
 143
 144 static inline BOOL isDirectory(struct AnchorPath *ap, BOOL followflag)
 145 {
 146     BOOL isdir;
 147
 148     if (ap->ap_Info.fib_DirEntryType == ST_SOFTLINK)
 149     {
 150         /* Softlink to dir/file - Default don't enter it, unless
 151            flag is set and the destination is really softlink.
 152
 153            We have all lost some files due to braindead behaviour
 154            of the original delete regarding softlinks. - Piru
 155         */
 156         isdir = FALSE;
 157
 158         if (followflag)
 159         {
 160             /* Okay flag set, figure out if this is a softlink to directory
 161             */
 162             BPTR lock;
 163
 164             lock = Lock(ap->ap_Buf, ACCESS_READ);
 165             if (lock)
 166             {
 167                 struct FileInfoBlock *fib;
 168
 169                 fib = AllocDosObject(DOS_FIB, NULL);
 170                 if (fib)
 171                 {
 172                     if (Examine(lock, fib))
 173                     {
 174                         /* Just extra sanity check so it can't be softlink
 175                            anymore (weird, fucked up, fs?).
 176                         */
 177                         isdir = (fib->fib_DirEntryType >= 0 &&
 178                                  fib->fib_DirEntryType != ST_SOFTLINK);
 179                     }
 180                     FreeDosObject(DOS_FIB, fib);
 181                 }
 182                 UnLock(lock);
 183             }
 184         }
 185     }
 186     else if (ap->ap_Info.fib_DirEntryType == ST_LINKDIR)
 187     {
 188         /* Hardlink to directory - Only follow it if flag set.
 189
 190            It is debatable whether hardlinks should be followed by
 191            default. IMHO not. - Piru
 192         */
 193         isdir = followflag;
 194     }
 195     else
 196     {
 197         isdir = ap->ap_Info.fib_DirEntryType >= 0;
 198     }
 199     return isdir;
 200 }
 201
 202 #define isDeletable(fib) (!((fib)->fib_Protection & FIBF_DELETE))
 203
 204 int doDelete(struct AnchorPath *ap, STRPTR *files, BOOL all, BOOL quiet,
 205              BOOL force, BOOL forcelinks)
 206 {
 207     LONG  match = 0;
 208     int   i;
 209     char  name[MAX_PATH_LEN];
 210     BOOL  deleteit = FALSE;
 211     BOOL  deletedfile = FALSE;
 212     BOOL  firstmatch = TRUE;
 213
 214     if (!files)
 215     {
 216         return RETURN_OK;
 217     }
 218
 219     for (i = 0; files[i] != NULL; i++)
 220     {
 221         /* Index for last character in the current file name (pattern name) */
 222         int lastIndex = strlen(files[i]) - 1;
 223
 224         if (files[i][lastIndex] == ':')
 225         {
 226             struct DosList *dl = LockDosList(LDF_ALL | LDF_READ);
 227
 228             if (FindDosEntry(dl, (CONST_STRPTR)files[i], LDF_ALL | LDF_READ))
 229             {
 230                 MatchEnd(ap);
 231                 UnLockDosList(LDF_ALL | LDF_READ);
 232
 233                 Printf("%s is a device and cannot be deleted\n", files[i]);
 234
 235                 return RETURN_FAIL;
 236             }
 237             UnLockDosList(LDF_ALL | LDF_READ);
 238         }
 239
 240         for (match = MatchFirst(files[i], ap); match == 0;
 241              match = MatchNext(ap))
 242         {
 243             firstmatch = FALSE;
 244
 245             if (CheckSignal(SIGBREAKF_CTRL_C))
 246             {
 247                 MatchEnd(ap);
 248                 PrintFault(ERROR_BREAK,"");
 249
 250                 return  RETURN_ERROR;
 251             }
 252
 253             if (deleteit)
 254             {
 255                 /* Try to delete the file or directory */
 256                 if (!DeleteFile(name))
 257                 {
 258                     LONG ioerr = IoErr();
 259                     Printf("%s  Not Deleted", (IPTR)name);
 260                     PrintFault(ioerr, "");
 261                 }
 262                 else if (!quiet)
 263                 {
 264                     Printf("%s  Deleted\n", (IPTR)name);
 265                 }
 266
 267                 deletedfile = TRUE;
 268                 deleteit = FALSE;
 269             }
 270
 271             /* If this is a directory, we enter it regardless if the ALL
 272                switch is set. */
 273             if (isDirectory(ap, forcelinks))
 274             {
 275                 /* This is a directory. It's important to check if we just left
 276                    the directory or is about to enter it. This is because we
 277                    cannot delete a directory until we have deleted all the
 278                    files in it. */
 279                 if (ap->ap_Flags & APF_DIDDIR)
 280                 {
 281                     /* If we get here, we are in ALL mode and have deleted
 282                        all the files inside the dir (if none were protected
 283                        and such). */
 284
 285                     ap->ap_Flags &= ~APF_DIDDIR;
 286
 287                     /* Now go on and delete the directory */
 288                 }
 289                 else
 290                 {
 291                     /* We stumbled upon a directory */
 292
 293                     if(all)
 294                     {
 295                         ap->ap_Flags |= APF_DODIR;
 296
 297                         /* We don't want to delete a directory before deleting
 298                            possible files inside it. Thus, match next file */
 299                         continue;
 300                     }
 301
 302                     /* If all is not set, DeleteFile() will return an error
 303                        in case the directory was not empty. */
 304                 }
 305             }
 306             /* Mark the entry for deletion */
 307             deleteit = TRUE;
 308
 309             /* Check permissions */
 310             if (!isDeletable(&ap->ap_Info))
 311             {
 312                 /* Consider delete protected file/dir 'deleted' */
 313                 deletedfile = TRUE;
 314
 315                 if (force)
 316                     SetProtection(ap->ap_Buf, 0);
 317                 else
 318                 {
 319                     Printf("%s  Not Deleted", (IPTR)ap->ap_Buf);
 320                     PrintFault(ERROR_DELETE_PROTECTED, "");
 321                     deleteit = FALSE;
 322                 }
 323             }
 324             strcpy(name, ap->ap_Buf);
 325         }
 326         MatchEnd(ap);
 327         if (deleteit)
 328         {
 329             /* Try to delete the file or directory */
 330             if (!DeleteFile(name))
 331             {
 332                 LONG ioerr = IoErr();
 333                 Printf("%s  Not Deleted", (IPTR)name);
 334                 PrintFault(ioerr, "");
 335             }
 336             else if (!quiet)
 337             {
 338                 Printf("%s  Deleted\n", (IPTR)name);
 339             }
 340
 341             deletedfile = TRUE;
 342             deleteit = FALSE;
 343         }
 344     }
 345
 346     if (firstmatch && match &&
 347         match != ERROR_OBJECT_NOT_FOUND &&
 348         match != ERROR_NO_MORE_ENTRIES)
 349     {
 350         PrintFault(match, NULL);
 351         return RETURN_WARN;
 352     }
 353
 354     if (!deletedfile)
 355     {
 356         PutStr("No file to delete\n");
 357         return RETURN_WARN;
 358     }
 359     return RETURN_OK;
 360 }