How to recursively set directory permissions with a find that lacks -exec?

Question

My Qnap NAS is cursed with a find command that lacks the -exec parameter, so I have to pipe to something. The shell is: GNU bash, version 3.2.57(2)-release-(arm-unknown-linux-gnueabihf)

I'm trying to set the setgid bit on all subdirectories (not files) of the current directory.

This does not work:

find . -type d | xargs chmod g+s $1

Using "$1", "$(1)", $("1") etc. will not work either. They all indicate that chmod is getting passed a directory name containing spaces as two or more parameters (it spits out its standard help message about what parameters are supported).

I don't care to use xargs if I don't have to; I think it chokes on long names anyway, doesn't it?

These and variants of them do not work:

find . -type d | chmod g+s

find . -type d | chmod g+s "$1"

I've thought of using awk or sed to inject quotation marks but I have to think there's an easier way to do this. What did people do before -exec? (The sad thing is that I probably knew, back in 1995 or so, but have long since forgotten.)

PS: Various of these directory names will contain Unicode characters, the ? symbol, etc. They're originally from macOS which is rather permissive. That said, I should probably replace all the ? instances with something like the Unicode character ⁇ so Windows doesn't choke on them. But that's also going to require a similar find operation with this crippleware version of find.

Answer 1

The output of find emits file names separated by newlines¹. This is not the format that xargs wants and find has no way to produce the format that xargs wants: it parses its input as whitespace-separated items, with \'" used for quoting. Some versions of xargs can take newline-separated input, but if your find lacks standard options, chances are that your xargs does too.

find . -type d | xargs chmod g+s works as long as your directory names don't contain whitespace or \'". Note that there's no $1: that's meaningful to a shell, but no shell is involved in parsing the output of find and feeding it to chmod, only xargs.

If your find has -print0 and your xargs has -0, you can use these options to pass null-delimited file names, which works with arbitrary file names.

find . -type d -print0 | xargs -0 chmod g+s

If your xargs supports the standard option -I, you can use it to instruct it to process each line as an item, instead of blank-separated quoted strings. This copes with spaces, but not with \"' or newlines.

find . -type d | xargs -I {} chmod g+s {}

You can use the shell to loop over lines instead of xargs. This works for any file name that doesn't contain newline characters.

find . -type d | while IFS= read -r line; do chmod g+s "$line"; done

Both of these solutions work only on file names that don't contain newline characters. The output of find with filenames containing newlines is ambiguous except in one case which is painful to parse: find won't spontaneously emit multiple slashes, so if you put // in the path to the directory to traverse, you can recognize this in the output. Here's some minimally tested code using that uses this fact to convert the output from find into the input format of xargs.

chars=$(printf '\t "'\\\')
{ find .//. -type d; echo .// } | LC_ALL=C sed -n '
s/['"$chars"']/\\&/g
/^\.\/\// {
x
s/\n/\\&/g
p
b
}
H' | LC_ALL=C xargs chmod g+s

¹ _{More precisely: terminated by newlines (there's a newline after the last name).}

Answer 2

You could do the recursion yourself with bash. Something like:

shopt -s nullglob dotglob
recurse_chmod () (
  cd "$1"
  for d in ./*/
  do
    if [ -L "$d" ]; then continue; fi
    chmod g+s "$d"
    recurse_chmod "$d"
  done
)
recurse_chmod .

Answer 3

You can tell xargs to use \0 as delimiter use find . -type d -print0 | xargs -0 chmod g+s

or

find . -type d | xargs -I{} -d '\n' chmod g+s "{}". It will use \n as delimiter.