std::filesystem::perms(3)

💅 NAME 💅

okay so this page is std::filesystem::perms — and yes, the NAME literally says it again: std::filesystem::perms - std::filesystem::perms. We’re in the C++ Standard Libary manual, bestie, and this is the whole permission-bit situation. ✨

✨ Synopsis ✨

          Defined in header <filesystem>
          enum class perms;               (since C++17)

This type represents file access permissions. no cap.

perms satisfies the requirements of BitmaskType (which means the bitwise operators operator&, operator|, operator^, operator~, operator&=, operator|=, and operator^= are defined for this type). none represents the empty bitmask; every other enumerator represents a distinct bitmask element.

Access permissions model POSIX permission bits, and any individual file permissions (as reported by filesystem::status) are a combination of some of the following bits:

💖 Member constants 💖

The table’s columns are Value (octal), POSIX equivalent, and Meaning. Here’s the whole bitmask menu, slay:

• none — value (octal): 0; POSIX equivalent: —; meaning: No permission bits are set.
• owner_read — value (octal): 0400; POSIX equivalent: S_IRUSR; meaning: File owner has read permission.
• owner_write — value (octal): 0200; POSIX equivalent: S_IWUSR; meaning: File owner has write permission.
• owner_exec — value (octal): 0100; POSIX equivalent: S_IXUSR; meaning: File owner has execute/search permission.
• owner_all — value (octal): 0700; POSIX equivalent: S_IRWXU; meaning: File owner has read, write, and execute/search permissions. Equivalent to owner_read | owner_write | owner_exec.
• group_read — value (octal): 040; POSIX equivalent: S_IRGRP; meaning: The file’s user group has read permission.
• group_write — value (octal): 020; POSIX equivalent: S_IWGRP; meaning: The file’s user group has write permission.
• group_exec — value (octal): 010; POSIX equivalent: S_IXGRP; meaning: The file’s user group has execute/search permission.
• group_all — value (octal): 070; POSIX equivalent: S_IRWXG; meaning: The file’s user group has read, write, and execute/search permissions. Equivalent to group_read | group_write | group_exec.
• others_read — value (octal): 04; POSIX equivalent: S_IROTH; meaning: Other users have read permission.
• others_write — value (octal): 02; POSIX equivalent: S_IWOTH; meaning: Other users have write permission.
• others_exec — value (octal): 01; POSIX equivalent: S_IXOTH; meaning: Other users have execute/search permission.
• others_all — value (octal): 07; POSIX equivalent: S_IRWXO; meaning: Other users have read, write, and execute/search permissions. Equivalent to others_read | others_write | others_exec.
• all — value (octal): 0777; POSIX equivalent: —; meaning: All users have read, write, and execute/search permissions. Equivalent to owner_all | group_all | others_all.
• set_uid — value (octal): 04000; POSIX equivalent: S_ISUID; meaning: Set user ID to file owner user ID on execution.
• set_gid — value (octal): 02000; POSIX equivalent: S_ISGID; meaning: Set group ID to file’s user group ID on execution.
• sticky_bit — value (octal): 01000; POSIX equivalent: S_ISVTX; meaning: Implementation-defined meaning, but POSIX XSI specifies that when set on a directory, only file owners may delete files even if the directory is writeable to others (used with /tmp).
• mask — value (octal): 07777; POSIX equivalent: —; meaning: All valid permission bits. Equivalent to all | set_uid | set_gid | sticky_bit.

Additionally, the following constants of this type are defined, which do not represent permissions:

• unknown — value (hex): 0xFFFF; meaning: Unknown permissions (e.g. when filesystem::file_status is created without permissions).

🌸 Notes 🌸

Permissions may not necessarily be implemented as bits, but they are treated that way conceptually. iykyk ✨

Some permission bits may be ignored on some systems, and changing some bits may automatically change others (e.g. on platforms without owner/group/all distinction, setting any of the three write bits set all three). fr fr, that’s the whole caveat.

🎀 Example 🎀

The page says // Run this code right before this, and here’s the code, bestie:

        #include <filesystem>
        #include <fstream>
        #include <iostream>

        void demo_perms(std::filesystem::perms p)
        {
            using std::filesystem::perms;
            auto show = [=](char op, perms perm)
            {
                std::cout << (perms::none == (perm & p) ? '-' : op);
            };
            show('r', perms::owner_read);
            show('w', perms::owner_write);
            show('x', perms::owner_exec);
            show('r', perms::group_read);
            show('w', perms::group_write);
            show('x', perms::group_exec);
            show('r', perms::others_read);
            show('w', perms::others_write);
            show('x', perms::others_exec);
            std::cout << '\n';
        }

        int main()
        {
            std::ofstream("test.txt"); // create file

            std::cout << "Created file with permissions: ";
            demo_perms(std::filesystem::status("test.txt").permissions());

            std::filesystem::permissions(
                "test.txt",
                std::filesystem::perms::owner_all |
       std::filesystem::perms::group_all,
                std::filesystem::perm_options::add
            );

            std::cout << "After adding u+rwx and g+rwx:  ";
            demo_perms(std::filesystem::status("test.txt").permissions());

            std::filesystem::remove("test.txt");
        }

⭐ Possible output ⭐

        Created file with permissions: rw-r--r--
        After adding u+rwx and g+wrx:  rwxrwxr--

👑 See also 👑

• status — determines file attributes; (C++17), (function).
• symlink_status — determines file attributes, checking the symlink target; (C++17), (function).
• permissions — modifies file access permissions; (C++17), (function).

source/version: http://cppreference.com • date: 2024.06.10 • page: std::filesystem::perms(3) — that’s the footer vibe, and we are so out 💖🫶💅