How to share file delete privilege when I opening a file by ifstream

Question

I want to make the file that can be delete when it was opened by ifstream.

I know it is easy when using Windows API: CreateFile

CreateFile(...,FILE_SHARE_DELETE,...)

But when I test with opening a file by ifstream.

It can't be deleted when I opening it.

I didn't find any document about setting attribute such like FILE_SHARE_DELETE on ifstream.

How should I do to solve this problem?

If I needed that I guess I'd look at ways to open an `ifstream` with an existing C `FILE` handle or file number, which in turn would correspond to an API level handle. Maybe — Cheers and hth. - Alf, Aug 15 '16 at 09:06
Some compilers (eg. `GCC`) offer the soon-to-be standard *filesystem* library as a `Technical Specification`. You can use: [std::experimental::filesystem::remove](http://en.cppreference.com/w/cpp/experimental/fs/remove). Otherwise there is the same (or similar) library in `boost`. — Galik, Aug 15 '16 at 09:13
For Alf's suggestion, see also http://stackoverflow.com/questions/475853/can-i-use-createfile-but-force-the-handle-into-a-stdofstream — andlabs, Aug 15 '16 at 12:21
Finally, I try to use Alf's suggestion and it works fine. Thanks for helping. — Min Mun, Aug 15 '16 at 15:32

score 5 · Accepted Answer · edited May 23 '17 at 12:25

Visual Studio's version of std::ifstream has a non-standard constructor and a non-standard open() overload that both have an extra optional _Prot parameter for specifying "file protection/sharing flags" (see _fsopen() for the list of available flags). However, delete sharing is not one of supported flags.

There is an alternative, though. Visual Studio's version of both std::ifstream and std::ofstream have non-standard constructors that accept a FILE* for the file access. You can wrap a HANDLE from CreateFile() into a FILE* using Microsoft's _open_osfhandle() and _fdopen() functions, for example (error handling removed for brevity):

Can I use CreateFile, but force the handle into a std::ofstream?

HANDLE file_handle = CreateFile(...,FILE_SHARE_DELETE,...);
int file_descriptor = _open_osfhandle((intptr_t)file_handle, _O_RDONLY);
FILE* file = _fdopen(file_descriptor, "r");
std::ifstream stream(file);
...
// Closes stream, file, file_descriptor, and file_handle.
stream.close();

If you need something more portable to non-Microsoft compilers, you will likely have to resort to writing a custom std::basic_streambuf class (or maybe derived from std::filebuf) to wrap your HANDLE, and then pass an object of that class to the std::basic_istream constructor directly.

This one is simple and easy than the accepted answer – Mohan Kumar Sep 22 '19 at 11:07 — Mohan Kumar, Sep 22 '19 at 11:07

score 2 · Answer 2 · edited May 23 '17 at 12:17

File permissions differ by operating system:

Windows has:

Whole-file access-sharing for read, write, or delete

*nix systems provide read, write, and execute permissions, but as far as delete permissions, all that is needed is:

write+execute permission on the parent directory. The permissions of the file itself are irrelevant

Since Windows is really the only system with delete access, and it already provides it's own accessor in the form of CreateFile with FILE_SHARE_DELETE, there really isn't a motivation to standardize this functionality.

If this functionality is pivotal to your program you could implement this cross-platform function (note that depending upon file size this could be very expensive):

Open file for read and write with an fstream; if this fails something else has a lock on the file and it would not be possible to open it for delete
Slurp the file
close the file
remove the file; if this fails you do not have delete permissions on the file
Reopen the file for writing with an ofstream
"Unslurp" the file into the ofstream
Return the ofstream

As long as the returned ofstream is open the operating system is responsible for preventing changes to the permissions on the file or it's containing directories. So by virtue of the fact that you have already deleted the file you know that you can still delete the file upon closing the ofstream.

How to share file delete privilege when I opening a file by ifstream

2 Answers2