chmod.c

   1 /*
   2     Copyright © 2013 Alastair Stuart
   3
   4     This program is open source software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12     GNU General Public License for more details.
  13 */
  14
  15 #include <errno.h>
  16 #include <stdbool.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include <dirent.h>
  22 #include <getopt.h>
  23 #include <sys/stat.h>
  24 #include <sys/types.h>
  25 #include <unistd.h>
  26
  27 #define VERSION "0.01"
  28
  29 bool errors = false;
  30
  31 // option flags
  32 struct {
  33     bool recursive;
  34 } flags;
  35
  36
  37 struct symbolic_mode
  38 {
  39     mode_t who;
  40     char operation;
  41     mode_t perm;
  42 };
  43
  44 mode_t user_flags[] = {
  45     S_IRUSR,
  46     S_IWUSR,
  47     S_IXUSR
  48 };
  49
  50 mode_t group_flags[] = {
  51     S_IRGRP,
  52     S_IWGRP,
  53     S_IXGRP
  54 };
  55
  56 mode_t other_flags[] = {
  57     S_IROTH,
  58     S_IWOTH,
  59     S_IXOTH
  60 };
  61
  62 bool isoctal(char ch)
  63 {
  64     return (ch >= '0' && ch <= '7');
  65 }
  66
  67 void usage(char* program)
  68 {
  69     printf("Usage: %s [options] [mode] [file ...]\n", program);
  70     printf("Changes file permissions.\n"
  71            "\n"
  72            "    -R         Run recursively.\n"
  73            "\n"
  74            "    --help     Print this message.\n"
  75            "    --version  Show version info.\n"
  76            "\n"
  77            "[mode] is in the form of [ugoa][+-=][rwx] or an octal number.\n");
  78 }
  79
  80 struct symbolic_mode* parse_mode_str(char* mode_str)
  81 {
  82     struct symbolic_mode *mode = calloc(1, sizeof(struct symbolic_mode));
  83
  84     // parse "who"
  85     size_t i = 0;
  86     for (i = 0; i < strlen(mode_str); i++)
  87     {
  88         switch (mode_str[i])
  89         {
  90             case 'u':
  91                 mode->who |= S_ISUID;
  92                 break;
  93             case 'g':
  94                 mode->who |= S_ISGID;
  95                 break;
  96             case 'o':
  97                 mode->who |= S_ISVTX;
  98                 break;
  99             case 'a':
 100                 mode->who = S_ISUID | S_ISGID | S_ISVTX;
 101                 break;
 102             case '+':
 103             case '-':
 104             case '=':
 105                 goto exit_loop;
 106                 break;
 107             default:
 108                 free(mode);
 109                 return NULL;
 110        }
 111     }
 112
 113 exit_loop:
 114     mode->operation = mode_str[i];
 115     i++;
 116     // parse permissions
 117     for ( ; i < strlen(mode_str); i++)
 118     {
 119         switch (mode_str[i])
 120         {
 121             case 'r':
 122                 mode->perm |= S_IROTH;
 123                 break;
 124             case 'w':
 125                 mode->perm |= S_IWOTH;
 126                 break;
 127             case 'x':
 128                 mode->perm |= S_IXOTH;
 129                 break;
 130             default:
 131                 free(mode);
 132                 return NULL;
 133         }
 134     }
 135
 136     return mode;
 137 }
 138
 139 mode_t equals_op(mode_t original, mode_t who, mode_t perm)
 140 {
 141     mode_t new = original;
 142     mode_t *flag_array = NULL;
 143
 144     while (who != 0)
 145     {
 146         if (who & S_ISUID) {
 147             flag_array = user_flags;
 148         } else if (who & S_ISGID) {
 149             flag_array = group_flags;
 150         } else if (who & S_ISVTX) {
 151             flag_array = other_flags;
 152         } else {
 153             return original;
 154         }
 155
 156         // turn off all the flags for that type
 157         for (int i = 0; i < 3; i++)
 158         {
 159             new &= ~(flag_array[i]);
 160         }
 161
 162         if (perm & S_IROTH) {
 163             new |= flag_array[0];
 164         }
 165         if (perm & S_IWOTH) {
 166             new |= flag_array[1];
 167         }
 168         if (perm & S_IXOTH) {
 169             new |= flag_array[2];
 170         }
 171
 172         if (flag_array == user_flags) {
 173             who &= ~S_ISUID;
 174         } else if (flag_array == group_flags) {
 175             who &= ~S_ISGID;
 176         } else if (flag_array == other_flags) {
 177             who &= ~S_ISVTX;
 178         } else {
 179             who = 0;
 180         }
 181     }
 182
 183     return new;
 184 }
 185
 186 void do_chmod(char* file, struct symbolic_mode *mode, mode_t change, char* argv0)
 187 {
 188     struct stat st;
 189     if (stat(file, &st) < 0) {
 190         fprintf(stderr, "%s: %s: %s\n",
 191                          argv0, strerror(errno), realpath(file, NULL));
 192         errors = true;
 193     }
 194
 195     mode_t final_mode = 0;
 196
 197     if (mode) {
 198         final_mode = st.st_mode;
 199
 200         switch (mode->operation)
 201         {
 202             case '+':
 203                 final_mode |= change;
 204                 break;
 205             case '-':
 206                 final_mode &= ~change;
 207                 break;
 208             case '=':
 209                 final_mode = equals_op(final_mode, mode->who, mode->perm);
 210                 break;
 211             default:
 212                 fprintf(stderr, "%s: No operation specified.\n", argv0);
 213                 errors = true;
 214         }
 215     } else {
 216         final_mode = change;
 217     }
 218
 219     if (chmod(file, final_mode) < 0) {
 220         fprintf(stderr, "%s: %s: %s\n",
 221                          argv0, strerror(errno), realpath(file, NULL));
 222         errors = true;
 223     }
 224
 225     if (S_ISDIR(st.st_mode) && flags.recursive) {
 226         if (chdir(file) == 0) {
 227             DIR *dp           = NULL;
 228             struct dirent *ep = NULL;
 229             dp = opendir(".");
 230             if (dp) {
 231                 while ((ep = readdir(dp)))
 232                 {
 233                     if (!(strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)) {
 234                         do_chmod(ep->d_name, mode, change, argv0);
 235                     }
 236                 }
 237                 closedir(dp);
 238             } else {
 239                 fprintf(stderr, "%s: %s: %s\n",
 240                                  argv0, strerror(errno), realpath(file, NULL));
 241                 errors = true;
 242             }
 243             chdir("..");
 244         } else {
 245             fprintf(stderr, "%s: %s: %s\n",
 246                              argv0, strerror(errno), realpath(file, NULL));
 247         }
 248     }
 249 }
 250
 251 int main(int argc, char* argv[])
 252 {
 253     flags.recursive = false;
 254     static struct option long_options[] = {
 255         {"recursive", no_argument, NULL, 'R'},
 256         {"help",      no_argument, NULL,  1},
 257         {"version",   no_argument, NULL,  2},
 258         {NULL, 0, NULL, 0}
 259     };
 260
 261     int c = 0;
 262     while ((c = getopt_long(argc, argv, "R",
 263                             long_options, NULL)) != -1)
 264     {
 265         switch (c)
 266         {
 267             case 'R':
 268                 flags.recursive = true;
 269                 break;
 270             case 1:
 271                 usage(argv[0]);
 272                 return 0;
 273             case 2:
 274                 printf("chmod (mutos) v"VERSION"\n");
 275                 return 0;
 276             default:
 277                 fprintf(stderr,"Run '%s --help' for usage.\n",
 278                                      argv[0]);
 279                 return 1;
 280         }
 281     }
 282
 283     if ((argc - optind) < 2) {
 284         fprintf(stderr, "%s: missing operands\n"
 285                         "Run '%s --help' for usage.\n",
 286                         argv[0], argv[0]);
 287         return 1;
 288     }
 289
 290     char* mode_str = argv[optind];
 291     optind++;
 292
 293     // check if mode is in octal form
 294     bool octal_mode = true;
 295     for (size_t i = 0; i < strlen(mode_str); i++)
 296     {
 297         if (!isoctal(mode_str[i])) {
 298             octal_mode = false;
 299         }
 300     }
 301
 302     if (octal_mode) {
 303         // convert string to octal number
 304         mode_t final_mode = strtoul(mode_str, NULL, 8);
 305         for (int i = 0; i < (argc - optind); i++)
 306         {
 307             do_chmod(argv[optind], NULL, final_mode, argv[0]);
 308         }
 309
 310         if (errors) {
 311             return 1;
 312         } else {
 313             return 0;
 314         }
 315
 316     }
 317
 318     struct symbolic_mode *mode = parse_mode_str(mode_str);
 319
 320     if (!mode) {
 321         fprintf(stderr, "%s: Invalid mode: %s\n",
 322                          argv[0],          mode_str);
 323         return 1;
 324     }
 325
 326     // if who is not specified, it defaults to user
 327     if (mode->who == 0) {
 328         mode->who = S_ISUID;
 329     }
 330
 331     mode_t change = 0;
 332
 333     if (mode->who & S_ISUID) {
 334         if (mode->perm & S_IROTH) {
 335             change |= S_IRUSR;
 336         }
 337         if (mode->perm & S_IWOTH) {
 338             change |= S_IWUSR;
 339         }
 340         if (mode->perm & S_IXOTH) {
 341             change |= S_IXUSR;
 342         }
 343     }
 344
 345     if (mode->who & S_ISGID) {
 346         if (mode->perm & S_IROTH) {
 347             change |= S_IRGRP;
 348         }
 349         if (mode->perm & S_IWOTH) {
 350             change |= S_IWGRP;
 351         }
 352         if (mode->perm & S_IXOTH) {
 353             change |= S_IXGRP;
 354         }
 355     }
 356
 357     if (mode->who & S_ISVTX) {
 358         if (mode->perm & S_IROTH) {
 359             change |= S_IROTH;
 360         }
 361         if (mode->perm & S_IWOTH) {
 362             change |= S_IWOTH;
 363         }
 364         if (mode->perm & S_IXOTH) {
 365             change |= S_IXOTH;
 366         }
 367     }
 368
 369     for (int i = 0; i < (argc - optind); i++)
 370     {
 371         do_chmod(argv[optind], mode, change, argv[0]);
 372     }
 373
 374     free(mode);
 375
 376     if (errors) {
 377         return 1;
 378     } else {
 379         return 0;
 380     }
 381 }