workbench/c/Delete.c

   1 /*
   2     Copyright © 1995-2004, 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         Workbench/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 suppresss 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 <stdio.h>
  72 #include <string.h>
  73
  74
  75 #define ARG_TEMPLATE    "FILE/M/A,ALL/S,QUIET/S,FORCE/S,FOLLOWLINKS/S"
  76
  77 enum
  78 {
  79     ARG_FILE = 0,
  80     ARG_ALL,
  81     ARG_QUIET,
  82     ARG_FORCE,
  83     ARG_FOLLOWLINKS,
  84     NOOFARGS
  85 };
  86
  87
  88 /* Maximum file path length */
  89 #define MAX_PATH_LEN    2048
  90
  91 static const char version[] = "$VER: Delete 41.2 (6.1.2000)\n";
  92 static char cmdname[] = "Delete";
  93
  94
  95 int doDelete(struct AnchorPath *ap, STRPTR *files, BOOL all, BOOL quiet,
  96              BOOL force, BOOL forcelinks);
  97
  98 int __nocommandline;
  99
 100 int main(void)
 101 {
 102     struct RDArgs      *rda;
 103     struct AnchorPath  *ap;
 104     IPTR                args[NOOFARGS] = { (IPTR) NULL, FALSE, FALSE, FALSE, FALSE };
 105     int                 retval         = RETURN_OK;
 106
 107     ap = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN,
 108                   MEMF_ANY | MEMF_CLEAR);
 109
 110     if (ap != NULL)
 111     {
 112         ap->ap_Strlen = MAX_PATH_LEN;
 113
 114         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 115
 116         if (rda != NULL)
 117         {
 118             /* Convert arguments into (less complex) variables */
 119             STRPTR *files = (STRPTR *)args[ARG_FILE];
 120             BOOL    all = (BOOL)args[ARG_ALL];
 121             BOOL    quiet = (BOOL)args[ARG_QUIET];
 122             BOOL    force = (BOOL)args[ARG_FORCE];
 123             BOOL    followlinks = (BOOL)args[ARG_FOLLOWLINKS];
 124
 125             retval = doDelete(ap, files, all, quiet, force, followlinks);
 126
 127             FreeArgs(rda);
 128         }
 129         else
 130         {
 131             PrintFault(IoErr(), cmdname);
 132             retval = RETURN_FAIL;
 133         }
 134     }
 135     else
 136     {
 137         retval = RETURN_FAIL;
 138     }
 139
 140     FreeVec(ap);
 141
 142     return retval;
 143 } /* main */
 144
 145 static inline BOOL isDirectory(struct AnchorPath *ap, BOOL followflag)
 146 {
 147     BOOL isdir;
 148
 149     if (ap->ap_Info.fib_DirEntryType == ST_SOFTLINK)
 150     {
 151         /* Softlink to dir/file - Default don't enter it, unless
 152            flag is set and the destination is really softlink.
 153
 154            We have all lost some files due to braindead behaviour
 155            of the original delete regarding softlinks. - Piru
 156         */
 157         isdir = FALSE;
 158
 159         if (followflag)
 160         {
 161             /* Okay flag set, figure out if this is a softlink to directory
 162             */
 163             BPTR lock;
 164
 165             lock = Lock(ap->ap_Buf, ACCESS_READ);
 166             if (lock)
 167             {
 168                 struct FileInfoBlock *fib;
 169
 170                 fib = AllocDosObject(DOS_FIB, NULL);
 171                 if (fib)
 172                 {
 173                     if (Examine(lock, fib))
 174                     {
 175                         /* Just extra sanity check so it can't be softlink
 176                            anymore (weird, fucked up, fs?).
 177                         */
 178                         isdir = (fib->fib_DirEntryType >= 0 &&
 179                                  fib->fib_DirEntryType != ST_SOFTLINK);
 180                     }
 181                     FreeDosObject(DOS_FIB, fib);
 182                 }
 183                 UnLock(lock);
 184             }
 185         }
 186     }
 187     else if (ap->ap_Info.fib_DirEntryType == ST_LINKDIR)
 188     {
 189         /* Hardlink to directory - Only follow it if flag set.
 190
 191            It is debatable whether hardlinks should be followed by
 192            default. IMHO not. - Piru
 193         */
 194         isdir = followflag;
 195     }
 196     else
 197     {
 198         isdir = ap->ap_Info.fib_DirEntryType >= 0;
 199     }
 200     return isdir;
 201 }
 202
 203 #define isDeletable(fib) (!((fib)->fib_Protection & FIBF_DELETE))
 204
 205 int doDelete(struct AnchorPath *ap, STRPTR *files, BOOL all, BOOL quiet,
 206              BOOL force, BOOL forcelinks)
 207 {
 208     LONG  match;
 209     int   i;
 210     char  name[MAX_PATH_LEN];
 211     BOOL  isfile = TRUE;
 212     BOOL  deleteit = FALSE;
 213     BOOL  deletedfile = FALSE;
 214     BOOL  firstmatch = TRUE;
 215     STRPTR file;
 216
 217     if (!files)
 218     {
 219         return RETURN_OK;
 220     }
 221
 222     for (i = 0; files[i] != NULL; i++)
 223     {
 224         /* Index for last character in the current file name (pattern name) */
 225         int lastIndex = strlen(files[i]) - 1;
 226
 227         if (files[i][lastIndex] == ':')
 228         {
 229             struct DosList *dl = LockDosList(LDF_ALL | LDF_READ);
 230
 231             if (FindDosEntry(dl, (CONST_STRPTR)files[i], LDF_ALL | LDF_READ))
 232             {
 233                 MatchEnd(ap);
 234                 UnLockDosList(LDF_ALL | LDF_READ);
 235
 236                 Printf("%s is a device and cannot be deleted\n", files[i]);
 237
 238                 return RETURN_FAIL;
 239             }
 240             UnLockDosList(LDF_ALL | LDF_READ);
 241         }
 242
 243         for (match = MatchFirst(files[i], ap); match == 0;
 244              match = MatchNext(ap))
 245         {
 246             firstmatch = FALSE;
 247
 248             if (CheckSignal(SIGBREAKF_CTRL_C))
 249             {
 250                 MatchEnd(ap);
 251                 PrintFault(ERROR_BREAK,"");
 252
 253                 return  RETURN_ERROR;
 254             }
 255
 256             if (deleteit)
 257             {
 258                 /* Try to delete the file or directory */
 259                 if (!DeleteFile(name))
 260                 {
 261                     LONG ioerr = IoErr();
 262                     Printf("%s  Not Deleted", (ULONG)name);
 263                     PrintFault(ioerr, "");
 264                 }
 265                 else if (!quiet)
 266                 {
 267                     Printf("%s  Deleted\n", (ULONG)name);
 268                 }
 269
 270                 deletedfile = TRUE;
 271                 deleteit = FALSE;
 272             }
 273
 274             /* If this is a directory, we enter it regardless if the ALL
 275                switch is set. */
 276             if (isDirectory(ap, forcelinks))
 277             {
 278                 /* This is a directory. It's important to check if we just left
 279                    the directory or is about to enter it. This is because we
 280                    cannot delete a directory until we have deleted all the
 281                    files in it. */
 282                 if (ap->ap_Flags & APF_DIDDIR)
 283                 {
 284                     /* If we get here, we are in ALL mode and have deleted
 285                        all the files inside the dir (if none were protected
 286                        and such). */
 287
 288                     ap->ap_Flags &= ~APF_DIDDIR;
 289
 290                     /* Now go on and delete the directory */
 291                 }
 292                 else
 293                 {
 294                     /* We stumbled upon a directory */
 295
 296                     if(all)
 297                     {
 298                         ap->ap_Flags |= APF_DODIR;
 299
 300                         /* We don't want to delete a directory before deleting
 301                            possible files inside it. Thus, match next file */
 302                         continue;
 303                     }
 304
 305                     /* If all is not set, DeleteFile() will return an error
 306                        in case the directory was not empty. */
 307                 }
 308             }
 309             /* Mark the entry for deletion */
 310             deleteit = TRUE;
 311
 312             /* Check permissions */
 313             if (!isDeletable(&ap->ap_Info))
 314             {
 315                 /* Consider delete protected file/dir 'deleted' */
 316                 deletedfile = TRUE;
 317
 318                 if (force)
 319                     SetProtection(ap->ap_Buf, 0);
 320                 else
 321                 {
 322                     Printf("%s  Not Deleted", (ULONG)ap->ap_Buf);
 323                     PrintFault(ERROR_DELETE_PROTECTED, "");
 324                     deleteit = FALSE;
 325                 }
 326             }
 327             isfile = !isDirectory(ap, forcelinks);
 328             strcpy(name, ap->ap_Buf);
 329         }
 330         MatchEnd(ap);
 331         if (deleteit)
 332         {
 333             /* Try to delete the file or directory */
 334             if (!DeleteFile(name))
 335             {
 336                 LONG ioerr = IoErr();
 337                 Printf("%s  Not Deleted", (ULONG)name);
 338                 PrintFault(ioerr, "");
 339             }
 340             else if (!quiet)
 341             {
 342                 Printf("%s  Deleted\n", (ULONG)name);
 343             }
 344
 345             deletedfile = TRUE;
 346             deleteit = FALSE;
 347         }
 348     }
 349
 350     if (firstmatch && match &&
 351         match != ERROR_OBJECT_NOT_FOUND &&
 352         match != ERROR_NO_MORE_ENTRIES)
 353     {
 354         PrintFault(match, NULL);
 355         return RETURN_WARN;
 356     }
 357
 358     if (!deletedfile)
 359     {
 360         PutStr("No file to delete\n");
 361         return RETURN_WARN;
 362     }
 363     return RETURN_OK;
 364 }