How to close file in C that is already opened - c++

Question

I am write application to read DICOM file and I must using other library to do it. I find that the library will open file but it don't close file when finishing. And the library is not open source. I know that open file limiting is 1024 in Linux and I can change the number. But I don't want to do the way. I like to close the file that is opened by library. How to close file in C if I know it is opening. I am using DICOM2NII library that is got from http://cbi.nyu.edu/software/dinifti.php.
And this is the code to open file but it does not close
bool DICOMImage::OpenFile(const char *path)
{
bool retValue = true;
DCM_Objects handle_;
unsigned long options = DCM_ORDERLITTLEENDIAN | DCM_FORMATCONVERSION | DCM_VRMASK;
// Try opening as PART10, if it fails it's might be bcause it does not have
// a preable and the try it that way
if ( DCM_OpenFile(path, options | DCM_PART10FILE, &handle_) != DCM_NORMAL )
{
DCM_CloseObject(&handle_);
COND_PopCondition(TRUE);
if ( DCM_OpenFile(path, options, &handle_) != DCM_NORMAL )
{
retValue = false;
}
else
retValue=true;
}
return retValue;
}

Answer 1

In your DICOMImage class, add a member
DCM_OBJECT *handle_;
and in your destructor close the file
DICOMImage::DICOMImage() : handle_(0) { ... }
DICOMImage::~DICOMImage() {
if (handle_ != 0)
DCM_CloseObject(&handle_);
}
and use this member handle_ in DICOMImage::OpenFile() as well, of course.

Answer 2

You could first test all file descriptors to see which ones are in use by doing a dummy fcntl(fd, F_GETFD) on every fd from 0 up to getdtablesize(). When the library function returns there will be one more open fd which you can just close with close(). You could also just call close(fd) on everything that wasn't open before and one of those will succeed (and you can stop at that point in your search).
It's likely you can do the initial probe up to the first unused fd and the library will end up using that fd provided it doesn't do anything more complex than open one file. If it opens multiple files or uses dup() it could end up elsewhere.
To spell this out:
#include <iostream>
#include <vector>
#include <unistd.h>
#include <fcntl.h>
std::vector<bool> getOpenFileMap()
{
int limit = getdtablesize();
std::vector<bool> result(limit);
for (int fd = 0; fd < limit; ++fd)
result[fd] = fcntl(fd, F_GETFD) != -1;
return result;
}
void closeOpenedFiles(const std::vector<bool> &existing)
{
int limit = existing.size();
for (int fd = 0; fd < limit; ++fd)
if (!existing[fd])
close(fd);
}
int getLikelyFd()
{
int limit = getdtablesize();
for (int fd = 0; fd < limit; ++fd)
if (fcntl(fd, F_GETFD) != -1)
return fd;
}
int main()
{
std::vector<bool> existing = getOpenFileMap();
int fd = open("/dev/null", O_RDONLY);
closeOpenedFiles(existing);
bool closed = write(fd, "test", 4) == -1;
std::cout << "complex pass " << std::boolalpha << closed << std::endl;
int guess = getLikelyFd();
fd = open("/dev/null", O_RDONLY);
bool match = fd == guess;
std::cout << "simple pass " << std::boolalpha << match << std::endl;
}