Return to chmod.cpp CVS log

Up to [Local Repository] / solidite / utils

Annotation of solidite/utils/chmod.cpp, revision 1.1.1.1

1.1       user        1: /* Copyright (c) 2026 The Solidite Developers
                      2:  *
                      3:  * This program is free software: you can redistribute it and/or modify it under
                      4:  * the terms of the GNU Affero General Public License as published by the Free
                      5:  * Software Foundation, either version 3 of the License, or (at your option)
                      6:  * any later version.
                      7:  *
                      8:  * This program is distributed in the hope that it will be useful, but WITHOUT
                      9:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
                     10:  * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
                     11:  * details.
                     12:  *
                     13:  * You should have received a copy of the GNU Affero General Public License
                     14:  * along with this program. If not, see <https://www.gnu.org/licenses/>. */
                     15: 
                     16: #include <bitset>
                     17: #include <filesystem>
                     18: #include <iostream>
                     19: #include <locale>
                     20: #include <string>
                     21: #include <sstream>
                     22: #include <vector>
                     23: 
                     24: #include <cstdint>
                     25: #include <cstring>
                     26: 
                     27: #include <sys/stat.h>
                     28: 
                     29: int main(int argc, char* argv[]) {
                     30:   // locale work
                     31:   std::locale::global(std::locale(""));
                     32:   std::cout.imbue(std::locale()); 
                     33:   std::wcout.imbue(std::locale()); 
                     34:   std::cerr.imbue(std::locale()); 
                     35:   std::wcerr.imbue(std::locale()); 
                     36: 
                     37:   std::bitset<3> options = 0b001;
                     38:   /* options[0]=process args? (-- not encountered), set to 0 if --
                     39:    * options[1]=recursive (if -R then true)
                     40:    * options[2]=mode found (if not found then error)
                     41:    * reminder std::bitset initializes RTL so 001 sets [0] to true*/
                     42: 
                     43:   std::vector<char*> files;
                     44:   uint_fast16_t mode = 511;
                     45:   // mode will get converted to octal
                     46: 
                     47:   for (int i = 1; i < argc; ++i) {
                     48:     if (options.test(0) == 0)
                     49:       files.push_back(argv[i]);
                     50:     else if (std::strcmp(argv[i], "--") == 0)
                     51:       options.reset(0);
                     52:     else if (options.test(1) == 0 && std::strcmp(argv[i], "-R") == 0)
                     53:       options.set(1);
                     54:     else if (options.test(2) == 0) {
                     55:       try {
                     56:         std::istringstream(argv[i]) >> std::oct >> mode;
                     57:       } catch (...) {
                     58:         std::cerr << "not an octal integer: " + std::string(argv[i]) + '\n';
                     59:         return 1;
                     60:       }
                     61:       options.set(2);
                     62:     } else
                     63:       files.push_back(argv[i]);
                     64:   }
                     65: 
                     66:   for (char* file : files) {
                     67:     try {
                     68:       if (options.test(1) == 0) {
                     69:         chmod(file, mode);
                     70:       } else {
                     71:         // loop through the files/folders recursively and chmod them
                     72:         chmod(file, mode); // chmod the original directory
                     73:         for (const std::filesystem::directory_entry& ENTRY :
                     74:              std::filesystem::recursive_directory_iterator(file)) {
                     75:           std::string what;
                     76:           chmod(ENTRY.path().string().c_str(), mode); // chmod the subdirectories
                     77:         }
                     78:       }
                     79:     } catch (...) {
                     80:       std::cerr << "failed to change permissions: " + std::string(file) + '\n';
                     81:       return 1;
                     82:     }
                     83:   }
                     84:   return 0;
                     85: }