How to make executable of all files excluding a few file types?

Question

I have a folder containing many C source file and the same number of its compiled output files.

I set executable bit to all this files but for some reason it was lost, making them not executable. (I think that's because I moved that folder to a NTFS partition for a while).

I would like to make them (but not the other files in my directory) executable again. One possible way is to move all source file from that folder to a temporary folder and do:

chmod +x *

Then move source files back to current folder.

Is it possible to do the same without moving files around?

Note:

Compiled output files are extension-less (in C).

Answer 1

That depends on how you define which files should be set as executables. For example, if consider all the files that do not have dot in filename, you can use:

find -type f -not -name "*.*" -exec chmod +x \{\} \;

This will find recursively all the files (not directories) that do not have dot in file name and set them executable. If you want to limit this to only current directory, add -maxdepth 1 argument, like this:

find -maxdepth 1 -type f -not -name "*.*" -exec chmod +x \{\} \;

You could also rely on file command which could tell you if a file is ELF executable. To do this, you could run something like:

find -type f -exec /bin/sh -c "file {} | grep -q executable && chmod +x {}" \;

This will recursively find all regular files and call file command on them. Then, grep will look for "executable" string in the output of this command (it should be something like ELF 32-bit LSB executable ...) and only if it finds it, chmod will be called on this file.

Of course, you can also add -maxdepth 1 in this case to disable recursive searching.

Answer 2

You could do something like:

find /pathtostuff -type f ! -name "*.c" -exec chmod +x {} +

This looks in /pathtostuff for files that lack a .c extension and adds the execute permissions to them.

UPDATE

This can be expanded to handle other C extensions too:

find . -type f ! -name "*.c" ! -name "*.h" ! -name "*.cc" ! -name "*.cpp" -exec chmod +x {} +

ALTERNATIVE APPROACH

This script is extension agnostic. It looks for files that are "binary" as opposed to "text".

#!/usr/bin/env perl
use strict;
use warnings;
use File::Find;
my @dir = @ARGV ? @ARGV : ('.');
my @files;
find( sub { -f $_ && !-T $_ && push @files, $File::Find::name }, @dir );
for my $file (@files) {
    system("echo  +x $file");
}

Simply pass the directory path to be examined. Run the script without any argument to process the current working directory.

Answer 3

In zsh:

setopt extendedglob
chmod +x -- ^*.c

With ksh, or bash with extglob option, or zsh with kshglob option:

chmod +x -- !(*.c)

With ksh93 (probably best to avoid playing with FIGNORE though):

FIGNORE='@(.*|*.c)'
chmod +x -- *

For all, replace *.c with *.* to exclude anything that has a dot.

With zsh, you can do nice things with globbing qualifiers, like:

oftype() [[ $(file -b --mime-type -- $REPLY) = $type ]]
type=application/x-executable; chmod +x -- **/*(.+oftype)

Which would match on regular files "oftype" application/x-executable (recursively descending into subdirectories).

Answer 4

This would also likely work

chmod +x $(find . -type f -print0 | xargs -0 file | grep "ELF [^,;]* executable" |  cut -d: -f1)

You'll still have problems if your files have spaces, tabs, newlines, asterisks, question marks, angle bracket or backslash characters in the names, or if there are too many of them to fit in one command line.