shell script to create empty files with all possible permissions - linux

Question

How to write a shell script that creates empty files with all possible permissions. File names should be, for example, rwxrw_r__.txt. I know how to do it manually. As an example:
#!/bin/bash
touch task5/rwxrwxrwx.txt | chmod 777 task5/rwxrwxrwx.txt
touch task5/rwxr-xr-x.txt | chmod 755 task5/rwxr-xr-x.txt
touch task5/rwx------.txt | chmod 700 task5/rwx------.txt
touch task5/rw-rw-rw-.txt | chmod 666 task5/rw-rw-rw-.txt
touch task5/rw-r--r--.txt | chmod 644 task5/rw-r--r--.txt
touch task5/rw-------.txt | chmod 600 task5/rw-------.txt
I do not know how to write a script that will create files according to the required template and give them permissions

Answer 1

Do a loop:
for ((i=0; i < 512; i++)); do
mod=$(printf "%03o" "$i");
touch ${mod}.txt; chmod $mod $mod.txt;
done
Rather than trying to construct the names, if you want the names to look like the output of ls -l, just do something like
for ((i=0; i < 512; i++)); do
mod=$(printf "%03o" "$i")
touch ${mod}.txt
chmod $mod $mod.txt
n=$(ls -l $mod.txt | cut -b1-10)
mv -- $mod.txt "$n.txt"
done

Answer 2

It's just a permutations problem.
p=( --- --x -w- -wx r-- r-x rw- rwx ) # the set of permissions
for u in "${p[#]}"; do for g in "${p[#]}"; do for o in "${p[#]}"; do
f="task5/$u$g$o.txt"; touch -- "$f" && chmod "u=${u//-/},g=${g//-/},o=${o//-/}" -- "$f";
done; done; done
NOTE
thanks to #kvantour for pointing out I was passing dashed to chmod, and that it doesn't know what to do with them. I am surprised I wasn't getting errors.
Let's break it down and look at what's happening.
If you have any questions about what permissions sets mean or how chmod works, see here.
So for each of the user, group, or other, there are eight possible symbolic representations (representing the values of one octal digit, 0-7).
We set those into a simple array we can loop over.
p=( --- --x -w- -wx r-- r-x rw- rwx ) # the set of permissions
You can access any element with it's octal digit (technically the decimal equivalent, but that doesn't matter unless you go over 7) so ${p[5]} is r-x. Indexing with # returns the whole array, so the loops walk through them sequentially with ${p[#]}.
To get every possible permutation, we loop over them for each of user/group/other.
for u in "${p[#]}"; do # assign each permission set for the user
for g in "${p[#]}"; do # assign each permission set for the group
for o in "${p[#]}"; do # assign each permission set for the other
This is just simple iterations in nested loops to hit every permutation.
f="task5/$u$g$o.txt" # assign the permissions string AS the filename
By putting the path and filename info into a variable, we can maintain any changes in one place, and it makes the rest of the line shorter and easier to read.
touch -- "$f" && # create the file and test for success
touch will create an empty file. Because the filenames could sometimes begin with a dash (any time the permissions disallow user read), we give touch a first argument of --, which is a *NIX standard idiom meaning "options are done now, anything left is arguments"; otherwise it would try to interpret a leading dash as an invalid option set and fail. This won't be a problem while you are putting "task5/" at the beginning of the filename, but if you end up using the filename bare it would.
The && is a boolean test to see whether touch succeeded. If it did not, then we silently skip trying the chmod (touch should have emitted an error message for your debugging, but if that fails, you probably got a ton of them, and will need to fix whatever ...)
chmod "u=${u//-/},g=${g//-/},o=${o//-/}" -- "$f" # change the permissions
This uses chmod's symbolic mode. We have the permissions of each section from the nexted loops - just apply them. Again, we use the -- to tell chmod when we are done passing options so that leading dashes in filenames won't be a problem later if you refactor just just cd into the directory and create the files locally, though even then you could always prefix ./ or $PWD/ on it.
We have to get rid of thew dashes in the symbolic file modes, though, as (thanks agains #kvantour) chmod doesn't recognize those. An inline string edit works beautirully: in "u=${u//-/},g=${g//-/},o=${o//-/}", the // inside the variable spec is a replacement of all occurrences, replacing - with the nothing between the following / and }.
done; done; done # these just close each of the loops
We could (and probably should) put each of these on separate lines, but the interpreter doesn't care since we used semicolons. It lets us compact the code to put the loop nesting and closures on lines together, so long as you are comfortable with the ONE thing that's changing being obvious enough.
Anything you still have questions about that I didn't cover?
Alternate
Another version, because I like going through a loop once instead of nested shenannigans...
p=( --- --x -w- -wx r-- r-x rw- rwx ) # the set of permissions
for dec in {0..511}; do oct="$(printf "%03o" "$dec")"
u="${p[${oct:0:1}]}"; g="${p[${oct:1:1}]}"; o="${p[${oct:2:1}]}";
f="task5/$u$g$o.txt"; touch "$f"; chmod "u=${u//-/},g=${g//-/},o=${o//-/}" "$f";
done
This walks through the combinations numerically, converts decimal to octal with printf, slices each digit out of the octal permission set with basic substring parsing and uses it to look up the relevant string from the array, assign the segments, assign the resulting filename, touch/create the file, then apply the scrubbed permissions strings with chmod. It's once-through and faster, if a little harder to understand.
u="${p[${oct:0:1}]}" # grabs 1 byte from offset 0 of $oct as index to $p
As suggested, to skip the decimal to octal conversion step, replace:
for dec in {0..511}; do oct="$(printf "%03o" "$dec")"
with
for oct in {0..7}{0..7}{0..7}; do

Answer 3

As per Paul Hodges answer - this is a permutation question - . However, this approach uses bash with SQLite in memory database to generate a data set inspired by this web page, https://towardsdatascience.com/unix-permissions-the-easy-way-98cc19979b3e creating a cartesian product out of eight records - generating the commands and placing the octal alongside the user group all permission set
The octal for the chmod is illustrated in this approach - which more aligns with the original request
#!/bin/bash
WorkingFolder=task5
RunnerFile=_T5Builder.bash
rm -Rf ${WorkingFolder} ${RunnerFile}
mkdir ${WorkingFolder}
sqlite3 << FIN
.headers off
.mode column
.once ${RunnerFile}
with cte_elements as (
select '0' as Id, '000' as Octal, '---' as Permission union
select '1', '001', '--x' union select '2', '010', '-w-' union
select '3', '011', '-wx' union select '4', '100', 'r--' union
select '5', '101', 'r-x' union select '6', '110', 'rw-' union
select '7', '111', 'rwx'
)
, cte_allpermissions as (
select cte_elements.Id || cte_elements1.Id || cte_elements2.Id as Dec
, cte_elements.Octal || cte_elements1.Octal || cte_elements2.Octal as OctFull
, cte_elements.Permission || cte_elements1.Permission || cte_elements2.Permission as Permission
from -- cartesian product
cte_elements cross join cte_elements cte_elements1 cross join cte_elements cte_elements2 --cartesian product
)
, cte_constructor as (
select 'touch ${WorkingFolder}/' || Dec || '_' || Permission || '.txt;' as "#TouchCommand"
, 'chmod ' || Dec || ' ${WorkingFolder}/' || Dec || '_' || Permission || '.txt ;' as ChmodCommand
, 'echo -n "' || Dec || ' "' as Progress
from cte_allpermissions
)
select * from cte_constructor;
FIN
chmod +x ${RunnerFile}
echo Top And Tail of Runner File ${RunnerFile}
head -2 ${RunnerFile}
tail -2 ${RunnerFile}
source ${RunnerFile}
echo
echo Done
ls -l ${WorkingFolder} | awk '{print $1, $9}' | more
Output as follows (takes about 40 seconds - if performance is really an issue
MyNode:~/viasql$ time ./CreateAllPermFiles.bash
Top And Tail of Runner File _T5Builder.bash
touch task5/000_---------.txt; chmod 000 task5/000_---------.txt ; echo -n "000 "
touch task5/001_--------x.txt; chmod 001 task5/001_--------x.txt ; echo -n "001 "
touch task5/776_rwxrwxrw-.txt; chmod 776 task5/776_rwxrwxrw-.txt ; echo -n "776 "
touch task5/777_rwxrwxrwx.txt; chmod 777 task5/777_rwxrwxrwx.txt ; echo -n "777 "
000 001 002 003 004 005 006 007 010 011 012 013 014 015 016 017 020 021 022 023 024 025 026 027 030 031 032 033 034 035 036 037 040 041 042 043 044 045 046 047 050 051 052 053 054 055 056 057 060 061 062 063 064 065 066 067 070 071 072 073 074 075 076 ...
First few files
... 761 762 763 764 765 766 767 770 771 772 773 774 775 776 777
Done
total
---------- 000_---------.txt
---------x 001_--------x.txt
--------w- 002_-------w-.txt
--------wx 003_-------wx.txt
-------r-- 004_------r--.txt
-------r-x 005_------r-x.txt
-------rw- 006_------rw-.txt
-------rwx 007_------rwx.txt
------x--- 010_-----x---.txt
------x--x 011_-----x--x.txt
------x-w- 012_-----x-w-.txt