Subject: Re: bug#21712: Suspected bug in find -exec '+'
From: Eric Blake <[email-masked]>
To: [email-masked], [email-masked], GNU bug control <[email-masked]>
Date: Mon, 19 Oct 2015 09:48:39 -0600
List-Id: <debbugs-submit.debbugs.gnu.org>

tag 21712 notabug
thanks

On 10/19/2015 05:33 AM, Richard White wrote:
> The find utility supports execution of a nominated command per file found.

Thanks for the report.  However, you sent it to the coreutils list,
although find is maintained by the findutils project.  Therefore, we
cannot address the bug here, and I'm marking the bug closed since it is
not a coreutils problem.  Feel free to make further comments on this
thread, though.

> It seems like find –exec ';' and find –exec '+' do not behave consistently with regard to '{}' argument expansion.  

Correct, they ARE different.  And this is behavior described by POSIX:

http://pubs.opengroup.org/onlinepubs/9699919799/utilities/find.html

-exec  utility_name  [argument ...] ;
-exec  utility_name  [argument ...]   {} +
    The end of the primary expression shall be punctuated by a
<semicolon> or by a <plus-sign>. Only a <plus-sign> that immediately
follows an argument containing only the two characters "{}" shall
punctuate the end of the primary expression. Other uses of the
<plus-sign> shall not be treated as special.

    If the primary expression is punctuated by a <semicolon>, the
utility utility_name shall be invoked once for each pathname and the
primary shall evaluate as true if the utility returns a zero value as
exit status. A utility_name or argument containing only the two
characters "{}" shall be replaced by the current pathname. If a
utility_name or argument string contains the two characters "{}", but
not just the two characters "{}", it is implementation-defined whether
find replaces those two characters or uses the string without change.

    If the primary expression is punctuated by a <plus-sign>, the
primary shall always evaluate as true, and the pathnames for which the
primary is evaluated shall be aggregated into sets. The utility
utility_name shall be invoked once for each set of aggregated pathnames.
Each invocation shall begin after the last pathname in the set is
aggregated, and shall be completed before the find utility exits and
before the first pathname in the next set (if any) is aggregated for
this primary, but it is otherwise unspecified whether the invocation
occurs before, during, or after the evaluations of other primaries. If
any invocation returns a non-zero value as exit status, the find utility
shall return a non-zero exit status. An argument containing only the two
characters "{}" shall be replaced by the set of aggregated pathnames,
with each pathname passed as a separate argument to the invoked utility
in the same order that it was aggregated. The size of any set of two or
more pathnames shall be limited such that execution of the utility does
not cause the system's {ARG_MAX} limit to be exceeded. If more than one
argument containing the two characters "{}" is present, the behavior is
unspecified.

> Is the latter result correct?  I would have expected the same result as for the ';' version?

As mentioned by the POSIX wording, you are attempting to do something
that is unspecified.  So all bets are off, and it's hard to call it a
bug.  In fact, I'd argue that:

find . -exec echo Prefix{}Suffix +

should be a usage error, rather than a valid find command, because there
is no terminating ';', and because the '+' is not proceeded by a lone
{}.  The fact that it is not a usage error may be a particular GNU find
extension, but you probably shouldn't rely on it.

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org