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 #define DEBUG 0
  71
  72 #include <aros/debug.h>
  73 #include <dos/dos.h>
  74 #include <dos/dosasl.h>
  75 #include <dos/dosextens.h>
  76 #include <dos/exall.h>
  77 #include <dos/rdargs.h>
  78 #include <exec/memory.h>
  79 #include <exec/types.h>
  80 #include <utility/utility.h>
  81
  82 #include <proto/arossupport.h>
  83 #include <proto/dos.h>
  84 #include <proto/exec.h>
  85 #include <proto/utility.h>
  86
  87 #define CTRL_C         (SetSignal(0L,0L) & SIGBREAKF_CTRL_C)
  88
  89 #define Bit_Mask(bit)           (1L << bit)
  90 #define Bit_Clear(name, bit)    name &= ~Bit_Mask(bit)
  91 #define Bit_Set(name, bit)      name |= Bit_Mask(bit)
  92
  93 #define ARG_TEMPLATE    "FILE/A,FLAGS,ADD/S,SUB/S,ALL/S,QUIET/S"
  94
  95 #ifndef FIBB_HOLD
  96 #define FIBB_HOLD 7
  97 #endif
  98 #ifndef FIBF_HOLD
  99 #define FIBF_HOLD (1<<FIBB_HOLD)
 100 #endif
 101
 102 enum
 103 {
 104     ARG_FILE = 0,
 105     ARG_FLAGS,
 106     ARG_ADD,
 107     ARG_SUB,
 108     ARG_ALL,
 109     ARG_QUIET,
 110     NOOFARGS
 111 };
 112
 113
 114 /* To define whether a command line switch was set or not.
 115  */
 116 #define NOT_SET(x)      (x == 0)
 117 #define IS_SET(x)       (!NOT_SET(x))
 118
 119 #define MAX_PATH_LEN    512
 120
 121 const TEXT version[] = "$VER: Protect 41.1 (2.12.2000)\n";
 122
 123 int Do_Protect(struct AnchorPath *, STRPTR, STRPTR, BOOL, BOOL, BOOL, BOOL);
 124
 125 int doProtect(struct AnchorPath *ap, STRPTR file, LONG flags, BOOL flagsSet,
 126               BOOL add, BOOL sub, BOOL all, BOOL quiet);
 127 BOOL setProtection(STRPTR file, LONG oldFlags, LONG flags, BOOL flagsSet,
 128                   BOOL add, BOOL sub);
 129
 130 int __nocommandline;
 131
 132 int main(void)
 133 {
 134     struct RDArgs     *rda;
 135     struct AnchorPath *apath;
 136
 137     IPTR args[NOOFARGS] = { 0,
 138                             0,
 139                             (IPTR)FALSE,
 140                             (IPTR)FALSE,
 141                             (IPTR)FALSE,
 142                             (IPTR)FALSE };
 143
 144     int retval = RETURN_OK;
 145
 146     apath = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN,
 147                      MEMF_ANY | MEMF_CLEAR);
 148
 149     if (apath != NULL)
 150     {
 151         /* Make sure DOS knows the buffer size. */
 152         apath->ap_Strlen = MAX_PATH_LEN;
 153
 154         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 155
 156         if (rda != NULL)
 157         {
 158             STRPTR  file = (STRPTR)args[ARG_FILE];
 159             STRPTR  flags = (STRPTR)args[ARG_FLAGS];
 160             BOOL    add = (BOOL)args[ARG_ADD];
 161             BOOL    sub = (BOOL)args[ARG_SUB];
 162             BOOL    all = (BOOL)args[ARG_ALL];
 163             BOOL    quiet = (BOOL)args[ARG_QUIET];
 164
 165             LONG    flagValues = FIBF_READ | FIBF_WRITE | FIBF_DELETE |
 166                                  FIBF_EXECUTE;
 167
 168             if (flags != NULL)
 169             {
 170                 D(Printf("Flags: %s\n", flags));
 171
 172                 if (*flags == '+')
 173                 {
 174                         add = TRUE;
 175                         flags++;
 176                 }
 177                 if (*flags == '-')
 178                 {
 179                         sub = TRUE;
 180                         flags++;
 181                 }
 182
 183                 while (*flags != 0 && retval == RETURN_OK)
 184                 {
 185                     char f = ToUpper(*flags);
 186
 187                     D(Printf("Checking flag: %lc\n", f));
 188                     switch (f)
 189                     {
 190                         /* Active low */
 191                         case 'R':
 192                             flagValues &= ~FIBF_READ;
 193                             break;
 194
 195                         case 'W':
 196                             flagValues &= ~FIBF_WRITE;
 197                             break;
 198
 199                         case 'D':
 200                             flagValues &= ~FIBF_DELETE;
 201                             break;
 202
 203                         case 'E':
 204                             flagValues &= ~FIBF_EXECUTE;
 205                             break;
 206
 207                             /* Active high */
 208                         case 'A':
 209                             flagValues |= FIBF_ARCHIVE;
 210                             break;
 211
 212                         case 'S':
 213                             flagValues |= FIBF_SCRIPT;
 214                             break;
 215
 216                         case 'P':
 217                             flagValues |= FIBF_PURE;
 218                             break;
 219
 220                         case 'H':
 221                             flagValues |= FIBF_HOLD;
 222                             break;
 223
 224                         default:
 225                             Printf("Invalid flags - must be one of HSPARWED\n");
 226                             retval = RETURN_FAIL;
 227                     }
 228
 229                     flags++;
 230                 } /* while (*flags != 0) */
 231             }
 232
 233             if (add && sub)
 234             {
 235                 Printf("ADD and SUB are mutually exclusive\n");
 236                 retval = RETURN_FAIL;
 237             }
 238
 239             if (retval == RETURN_OK)
 240             {
 241                 if (!all && IsDosEntryA(file, LDF_VOLUMES | LDF_DEVICES))
 242                 {
 243                     Printf("Can't set protection for %s - ", file);
 244                     SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 245                     PrintFault(IoErr(), NULL);
 246
 247                     retval = RETURN_FAIL;
 248                 }
 249                 else
 250                 {
 251                     retval = doProtect(apath, file, flagValues,
 252                                        flags != NULL, add, sub, all,
 253                                        quiet);
 254                 }
 255             }
 256
 257             FreeArgs(rda);
 258         }
 259         else
 260         {
 261             PrintFault(IoErr(), "Protect");
 262             retval = RETURN_FAIL;
 263         }
 264     }
 265     else
 266     {
 267         retval = RETURN_FAIL;
 268     }
 269
 270     FreeVec(apath);
 271
 272     return retval;
 273 }
 274
 275 #define  isDir(fib) ((fib)->fib_DirEntryType >= 0)
 276
 277 int doProtect(struct AnchorPath *ap, STRPTR file, LONG flags, BOOL flagsSet,
 278               BOOL add, BOOL sub, BOOL all, BOOL quiet)
 279 {
 280     LONG  match;
 281     int   retval = RETURN_OK;
 282     LONG  indent = 0;
 283     int   i;                    /* Loop variable */
 284     BOOL  success;
 285     ULONG match_count = 0;
 286
 287     for (match = MatchFirst(file, ap);
 288          match == 0 && retval == RETURN_OK && !CTRL_C;
 289          match = MatchNext(ap))
 290     {
 291         match_count++;
 292         if (isDir(&ap->ap_Info))
 293         {
 294             if (ap->ap_Flags & APF_DIDDIR)
 295             {
 296                 indent--;
 297                 ap->ap_Flags &= ~APF_DIDDIR; /* Should not be necessary */
 298                 continue;
 299             }
 300             else if (all)
 301             {
 302                 ap->ap_Flags |= APF_DODIR;
 303                 indent++;
 304             }
 305
 306
 307         }
 308
 309         success = setProtection(ap->ap_Buf, ap->ap_Info.fib_Protection, flags,
 310                               flagsSet, add, sub);
 311
 312         if (!quiet)
 313         {
 314             LONG ioerr = IoErr();
 315
 316             /* Fix indentation level */
 317             for (i = 0; i < indent; i++)
 318             {
 319                 PutStr("     ");
 320             }
 321
 322             if (!isDir(&ap->ap_Info))
 323             {
 324                 PutStr("   ");
 325             }
 326
 327             PutStr(ap->ap_Info.fib_FileName);
 328
 329             if (isDir(&ap->ap_Info))
 330             {
 331                 PutStr(" (dir)");
 332             }
 333
 334             if (!success)
 335             {
 336                 PrintFault(ioerr, "..error");
 337                 retval = RETURN_ERROR;
 338             }
 339             else
 340             {
 341                 PutStr("..done\n");
 342             }
 343         }
 344     }
 345
 346     if (match_count == 0 || IoErr() != ERROR_NO_MORE_ENTRIES)
 347     {
 348         PrintFault(IoErr(), NULL);
 349         retval = RETURN_ERROR;
 350     }
 351
 352     MatchEnd(ap);
 353
 354     return retval;
 355 }
 356
 357 #define  ALL_OFF  (FIBF_READ | FIBF_WRITE | FIBF_DELETE | FIBF_EXECUTE)
 358 #define addFlags(new, old)  ((~(~old | ~new) & ALL_OFF) | \
 359                               ((old | new) & ~ALL_OFF))
 360
 361 #define  subFlags(new, old)  (((old | ~new) & ALL_OFF) | \
 362                               ((old & ~new) & ~ALL_OFF))
 363
 364 BOOL setProtection(STRPTR file, LONG oldFlags, LONG flags, BOOL flagsSet,
 365                    BOOL add, BOOL sub)
 366 {
 367     LONG  newFlags;
 368
 369     if (flags != ALL_OFF)
 370     {
 371         if (add)
 372         {
 373             /* Enable permission */
 374             newFlags = addFlags(flags, oldFlags);
 375         }
 376         else if (sub)
 377         {
 378             /* Disable permissions */
 379             newFlags = subFlags(flags, oldFlags);
 380         }
 381         else
 382         {
 383             /* Clear all permissions then set the ones given. */
 384             newFlags = flags;
 385         }
 386     }
 387     else
 388     {
 389         /* No flags were given */
 390         if (!add && !sub)
 391         {
 392             /* Disable all permissions */
 393             newFlags = ALL_OFF;
 394         }
 395         else
 396         {
 397             /* Do nothing */
 398             return FALSE;
 399         }
 400     }
 401
 402     if (!SetProtection(file, newFlags))
 403     {
 404         return FALSE;
 405     }
 406
 407     return TRUE;
 408 }