workbench/c/Protect.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Protect CLI command
   6     Lang: English
   7 */
   8
   9 /*****************************************************************************
  10
  11     NAME
  12
  13         Protect
  14
  15     SYNOPSIS
  16
  17         FILE/A,FLAGS,ADD/S,SUB/S,ALL/S,QUIET/S
  18
  19     LOCATION
  20
  21         C:
  22
  23     FUNCTION
  24
  25         Add or remove protection bits from a file or directory.
  26
  27         Protect allows the use of pattern matching and recursive directory
  28         scans to protect many files/directories at any one time.
  29
  30     INPUTS
  31
  32         FILE   --  Either a file, a directory or a pattern to match.
  33         FLAGS  --  One or more of the following flags:
  34
  35                     S - Script
  36                     P - Pure
  37                     A - Archive
  38                     R - Read
  39                     W - Write
  40                     E - Execute
  41                     D - Delete
  42
  43         ADD    --  Allows the bits to be set and hence allowable.
  44         SUB    --  Allows the bits to be cleared and hence not allowable.
  45         ALL    --  Allows a recursive scan of the volume/directory.
  46         QUIET  --  Suppresses any output to the shell.
  47
  48     RESULT
  49
  50         Standard DOS return codes.
  51
  52     NOTES
  53
  54     EXAMPLE
  55
  56         Protect ram: e add all
  57
  58             Recurses the ram: volume and attaches the executable bit.
  59
  60     BUGS
  61
  62     SEE ALSO
  63
  64         dos.library/SetProtection()
  65
  66     INTERNALS
  67
  68 ******************************************************************************/
  69
  70
  71 #include <dos/dos.h>
  72 #include <dos/dosasl.h>
  73 #include <dos/dosextens.h>
  74 #include <dos/exall.h>
  75 #include <dos/rdargs.h>
  76 #include <exec/memory.h>
  77 #include <exec/types.h>
  78 #include <utility/utility.h>
  79
  80 #include <proto/arossupport.h>
  81 #include <proto/dos.h>
  82 #include <proto/exec.h>
  83
  84 #include <ctype.h>
  85
  86 #define CTRL_C         (SetSignal(0L,0L) & SIGBREAKF_CTRL_C)
  87
  88 #define Bit_Mask(bit)           (1L << bit)
  89 #define Bit_Clear(name, bit)    name &= ~Bit_Mask(bit)
  90 #define Bit_Set(name, bit)      name |= Bit_Mask(bit)
  91
  92 #define ARG_TEMPLATE    "FILE/A,FLAGS,ADD/S,SUB/S,ALL/S,QUIET/S"
  93
  94 #ifndef FIBB_HOLD
  95 #define FIBB_HOLD 7
  96 #endif
  97 #ifndef FIBF_HOLD
  98 #define FIBF_HOLD (1<<FIBB_HOLD)
  99 #endif
 100
 101 enum
 102 {
 103     ARG_FILE = 0,
 104     ARG_FLAGS,
 105     ARG_ADD,
 106     ARG_SUB,
 107     ARG_ALL,
 108     ARG_QUIET,
 109     NOOFARGS
 110 };
 111
 112
 113 /* To define whether a command line switch was set or not.
 114  */
 115 #define NOT_SET(x)      (x == 0)
 116 #define IS_SET(x)       (!NOT_SET(x))
 117
 118 #define MAX_PATH_LEN    512
 119
 120 const TEXT version[] = "$VER: Protect 41.1 (2.12.2000)\n";
 121
 122 struct UtilityBase *UtilityBase;
 123
 124 int Do_Protect(struct AnchorPath *, STRPTR, STRPTR, BOOL, BOOL, BOOL, BOOL);
 125
 126 int doProtect(struct AnchorPath *ap, STRPTR file, LONG flags, BOOL flagsSet,
 127               BOOL add, BOOL sub, BOOL all, BOOL quiet);
 128 BOOL setProtection(STRPTR file, LONG oldFlags, LONG flags, BOOL flagsSet,
 129                   BOOL add, BOOL sub);
 130
 131 int __nocommandline;
 132
 133 int main(void)
 134 {
 135     struct RDArgs     *rda;
 136     struct AnchorPath *apath;
 137
 138     IPTR args[NOOFARGS] = { NULL,
 139                             NULL,
 140                             (IPTR)FALSE,
 141                             (IPTR)FALSE,
 142                             (IPTR)FALSE,
 143                             (IPTR)FALSE };
 144
 145     int retval = RETURN_OK;
 146
 147     apath = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN,
 148                      MEMF_ANY | MEMF_CLEAR);
 149
 150     if (apath != NULL)
 151     {
 152         /* Make sure DOS knows the buffer size. */
 153         apath->ap_Strlen = MAX_PATH_LEN;
 154
 155         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 156
 157         if (rda != NULL)
 158         {
 159             STRPTR  file = (STRPTR)args[ARG_FILE];
 160             STRPTR  flags = (STRPTR)args[ARG_FLAGS];
 161             BOOL    add = (BOOL)args[ARG_ADD];
 162             BOOL    sub = (BOOL)args[ARG_SUB];
 163             BOOL    all = (BOOL)args[ARG_ALL];
 164             BOOL    quiet = (BOOL)args[ARG_QUIET];
 165
 166             LONG    flagValues = FIBF_READ | FIBF_WRITE | FIBF_DELETE |
 167                                  FIBF_EXECUTE;
 168
 169             if (flags != NULL)
 170             {
 171                 if (*flags == '+')
 172                 {
 173                         add = TRUE;
 174                         flags++;
 175                 }
 176                 if (*flags == '-')
 177                 {
 178                         sub = TRUE;
 179                         flags++;
 180                 }
 181
 182                 while (*flags != 0 && retval == RETURN_OK)
 183                 {
 184                     switch (toupper(*flags))
 185                     {
 186                         /* Active low */
 187                         case 'R':
 188                             flagValues &= ~FIBF_READ;
 189                             break;
 190
 191                         case 'W':
 192                             flagValues &= ~FIBF_WRITE;
 193                             break;
 194
 195                         case 'D':
 196                             flagValues &= ~FIBF_DELETE;
 197                             break;
 198
 199                         case 'E':
 200                             flagValues &= ~FIBF_EXECUTE;
 201                             break;
 202
 203                             /* Active high */
 204                         case 'A':
 205                             flagValues |= FIBF_ARCHIVE;
 206                             break;
 207
 208                         case 'S':
 209                             flagValues |= FIBF_SCRIPT;
 210                             break;
 211
 212                         case 'P':
 213                             flagValues |= FIBF_PURE;
 214                             break;
 215
 216                         case 'H':
 217                             flagValues |= FIBF_HOLD;
 218                             break;
 219
 220                         default:
 221                             Printf("Invalid flags - must be one of HSPARWED\n");
 222                             retval = RETURN_FAIL;
 223                     }
 224
 225                     flags++;
 226                 } /* while (*flags != 0) */
 227             }
 228
 229             if (add && sub)
 230             {
 231                 Printf("ADD and SUB are mutually exclusive\n");
 232                 retval = RETURN_FAIL;
 233             }
 234
 235             if (retval == RETURN_OK)
 236             {
 237                 if (!all && IsDosEntryA(file, LDF_VOLUMES | LDF_DEVICES))
 238                 {
 239                     Printf("Can't set protection for %s - ", file);
 240                     SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 241                     PrintFault(IoErr(), NULL);
 242
 243                     retval = RETURN_FAIL;
 244                 }
 245                 else
 246                 {
 247                     retval = doProtect(apath, file, flagValues,
 248                                        flags != NULL, add, sub, all,
 249                                        quiet);
 250                 }
 251             }
 252
 253             FreeArgs(rda);
 254         }
 255         else
 256         {
 257             PrintFault(IoErr(), "Protect");
 258             retval = RETURN_FAIL;
 259         }
 260     }
 261     else
 262     {
 263         retval = RETURN_FAIL;
 264     }
 265
 266     FreeVec(apath);
 267
 268     return retval;
 269 }
 270
 271 #define  isDir(fib) ((fib)->fib_DirEntryType >= 0)
 272
 273 int doProtect(struct AnchorPath *ap, STRPTR file, LONG flags, BOOL flagsSet,
 274               BOOL add, BOOL sub, BOOL all, BOOL quiet)
 275 {
 276     LONG  match;
 277     int   retval = RETURN_OK;
 278     LONG  indent = 0;
 279     int   i;                    /* Loop variable */
 280     BOOL  success;
 281     ULONG match_count = 0;
 282
 283     for (match = MatchFirst(file, ap);
 284          match == 0 && retval == RETURN_OK && !CTRL_C;
 285          match = MatchNext(ap))
 286     {
 287         match_count++;
 288         if (isDir(&ap->ap_Info))
 289         {
 290             if (ap->ap_Flags & APF_DIDDIR)
 291             {
 292                 indent--;
 293                 ap->ap_Flags &= ~APF_DIDDIR; /* Should not be necessary */
 294                 continue;
 295             }
 296             else if (all)
 297             {
 298                 ap->ap_Flags |= APF_DODIR;
 299                 indent++;
 300             }
 301
 302
 303         }
 304
 305         success = setProtection(ap->ap_Buf, ap->ap_Info.fib_Protection, flags,
 306                               flagsSet, add, sub);
 307
 308         if (!quiet)
 309         {
 310             LONG ioerr = IoErr();
 311
 312             /* Fix indentation level */
 313             for (i = 0; i < indent; i++)
 314             {
 315                 PutStr("     ");
 316             }
 317
 318             if (!isDir(&ap->ap_Info))
 319             {
 320                 PutStr("   ");
 321             }
 322
 323             PutStr(ap->ap_Info.fib_FileName);
 324
 325             if (isDir(&ap->ap_Info))
 326             {
 327                 PutStr(" (dir)");
 328             }
 329
 330             if (!success)
 331             {
 332                 PrintFault(ioerr, "..error");
 333                 retval = RETURN_ERROR;
 334             }
 335             else
 336             {
 337                 PutStr("..done\n");
 338             }
 339         }
 340     }
 341
 342     if (match_count == 0 || IoErr() != ERROR_NO_MORE_ENTRIES)
 343     {
 344         PrintFault(IoErr(), NULL);
 345         retval = RETURN_ERROR;
 346     }
 347
 348     MatchEnd(ap);
 349
 350     return retval;
 351 }
 352
 353 #define  ALL_OFF  (FIBF_READ | FIBF_WRITE | FIBF_DELETE | FIBF_EXECUTE)
 354 #define addFlags(new, old)  ((~(~old | ~new) & ALL_OFF) | \
 355                               ((old | new) & ~ALL_OFF))
 356
 357 #define  subFlags(new, old)  (((old | ~new) & ALL_OFF) | \
 358                               ((old & ~new) & ~ALL_OFF))
 359
 360 BOOL setProtection(STRPTR file, LONG oldFlags, LONG flags, BOOL flagsSet,
 361                    BOOL add, BOOL sub)
 362 {
 363     LONG  newFlags;
 364
 365     if (flags != ALL_OFF)
 366     {
 367         if (add)
 368         {
 369             /* Enable permission */
 370             newFlags = addFlags(flags, oldFlags);
 371         }
 372         else if (sub)
 373         {
 374             /* Disable permissions */
 375             newFlags = subFlags(flags, oldFlags);
 376         }
 377         else
 378         {
 379             /* Clear all permissions then set the ones given. */
 380             newFlags = flags;
 381         }
 382     }
 383     else
 384     {
 385         /* No flags were given */
 386         if (!add && !sub)
 387         {
 388             /* Disable all permissions */
 389             newFlags = ALL_OFF;
 390         }
 391         else
 392         {
 393             /* Do nothing */
 394             return FALSE;
 395         }
 396     }
 397
 398     if (!SetProtection(file, newFlags))
 399     {
 400         return FALSE;
 401     }
 402
 403     return TRUE;
 404 }