The 'os.stat' method on windows seems to be hardcoded to check the file name extension when computing the 'executable permission flag' (st_mode).

(See Modules/posixmodule.c:  win32_stat and win32_wstat)

Currently, it checks for : 
 '.bat', '.cmd', '.exe', '.com'

As dynamic libraries also must be executable on window, t should also check for : 
 '.dll'

It would be even better if the actual 'read and execute' permission is returned.

The "Read & Execute" permission listed on a file's property window doesn't really mean anything. Executables only need read permissions [0] to actually be executed.

Additionally, in terms of _stat, Windows does its check by extension [1] but they don't specify what extensions they look for.

Adding ".dll" checking would be the most we could do here.



[0] http://technet.microsoft.com/en-us/library/bb727008.aspx
[1] See "st_mode" halfway down the page, http://msdn.microsoft.com/en-us/library/14h5k7ff(v=VS.90).aspx

Some more background:
The actual issue was initially detected when observing that the 'tarfile' package produced a tar containing different permissions, depending on the script being executed by 'cygwin python' or 'native python'.

When using native python to do the 'untar', I did not observe any issue (as it seems to automatically add 'read and execute' for all files).
But, when I used 'cygwin tar', the .dll did not get its 'read and execute' permission (as it was not specified in the tar file), which then resulted in program that crashed (with a very unhelpful message). Allowing 'read and execute' manually resolved the crash.

So, although this permission should not mean anything, it does seem to have some influence :(

> The actual issue was initially detected when observing that the
> 'tarfile' package produced a tar containing different permissions,
> depending on the script being executed by 'cygwin python' or 'native python'.

I would expect that. Each of those work in their own world when it comes to file permissions, and there really isn't a 1-to-1 match when it comes to working in both environments.


On native Windows, "Read & Execute" has no real affect on applications, as it appears to be a synthetic permission probably constructed for that property window. I just looked at a number of definitely not executable files on my computer (e.g., text files), and they are all listed as "Read & Execute". Even by right clicking and adding a new file with a garbage name, no extension, and no contents, it's still "Read & Execute" enabled.

Additionally, there is no programmatic way to set that "Read & Execute" flag that you see in the property window.

Brian: "On native Windows, "Read & Execute" has no real affect on applications". Why do you say that? The FILE_EXECUTE permission certainly has a meaning on Windows, see

http://msdn.microsoft.com/en-us/library/gg258116(v=vs.85).aspx

I agree that FILE_EXECUTE is, in principle, mostly the equivalent of the x bit on POSIX. Unfortunately, it's also confusing, since most files have that permission.

I meant that it doesn't have any effect because it's apparently always set from what I could see, which was poor wording. The TechNet article also made a similar claim. If it is ever not set, then the file clearly can't be executed.

From reading http://support.microsoft.com/kb/899147 it does look like the .dll extension needs to have the "Read & Execute" permission in order to have code from the .dll be executed. It's odd that there isn't documentation that's easily searchable to confirm this.

Also what about scripts, .vbs, .ps1 etc. Should those be considered executables as well?

Jeroen: I'm tempted to close this issue with no change. The code, as it stands, models what Microsoft does in it's CRT (see crt/src/stat.c:__tdtoxmode). There is also a straight-forward motivation to this: this is the list of extensions that you can pass to system() and friends (i.e. ultimately to CreateProcess, if cmd.exe can get involved).

FWIW I agree with MvL: os.stat is one of those awkward customers
left over from the idea that Windows could be posix-compliant,
even though the relevant concepts don't actually map particularly
well. ISTM that anyone seriously wanting to determine whether
something's executable or not on Windows is going to have in
mind the precise semantics of a particular use-case and will
employ whatever API calls meet that need. I genuinely don't
believe there's any mileage in shoehorning more and more
corner-cases into os.stat on Windows.

Closing as suggested.