fmt/posix.cc

238 lines
7.1 KiB
C++
Raw Normal View History

2014-06-09 15:33:48 +00:00
/*
A C++ interface to POSIX functions.
Copyright (c) 2014, Victor Zverovich
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "posix.h"
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifndef _WIN32
# include <unistd.h>
#else
2014-09-12 18:57:33 +00:00
# include <windows.h>
2014-06-09 15:33:48 +00:00
# include <io.h>
# define O_CREAT _O_CREAT
# define O_TRUNC _O_TRUNC
2014-07-09 15:39:01 +00:00
#ifndef S_IRUSR
2014-06-09 15:33:48 +00:00
# define S_IRUSR _S_IREAD
2014-07-09 15:39:01 +00:00
#endif
#ifndef S_IWUSR
2014-06-09 15:33:48 +00:00
# define S_IWUSR _S_IWRITE
2014-07-09 15:39:01 +00:00
#endif
2014-06-09 15:33:48 +00:00
2014-06-10 22:38:57 +00:00
# ifdef __MINGW32__
# define _SH_DENYNO 0x40
# endif
2014-06-09 15:33:48 +00:00
#endif // _WIN32
namespace {
#ifdef _WIN32
// Return type of read and write functions.
typedef int RWResult;
2014-06-09 15:33:48 +00:00
// On Windows the count argument to read and write is unsigned, so convert
// it from size_t preventing integer overflow.
inline unsigned convert_rwcount(std::size_t count) {
2014-06-09 15:33:48 +00:00
return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
}
#else
// Return type of read and write functions.
typedef ssize_t RWResult;
inline std::size_t convert_rwcount(std::size_t count) { return count; }
2014-06-09 15:33:48 +00:00
#endif
}
fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT(true) {
2014-06-09 15:33:48 +00:00
if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
fmt::report_system_error(errno, "cannot close file");
2014-06-09 15:33:48 +00:00
}
fmt::BufferedFile::BufferedFile(fmt::StringRef filename, fmt::StringRef mode) {
2014-08-28 19:13:03 +00:00
FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
if (!file_)
2014-08-28 21:51:01 +00:00
throw SystemError(errno, "cannot open file {}", filename);
}
void fmt::BufferedFile::close() {
2014-06-09 15:33:48 +00:00
if (!file_)
return;
int result = FMT_SYSTEM(fclose(file_));
file_ = 0;
if (result != 0)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot close file");
2014-06-09 15:33:48 +00:00
}
int fmt::BufferedFile::fileno() const {
2014-06-09 15:33:48 +00:00
int fd = FMT_POSIX_CALL(fileno(file_));
if (fd == -1)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot get file descriptor");
2014-06-09 15:33:48 +00:00
return fd;
}
fmt::File::File(fmt::StringRef path, int oflag) {
2014-06-09 15:33:48 +00:00
int mode = S_IRUSR | S_IWUSR;
#ifdef _WIN32
fd_ = -1;
FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
2014-06-09 15:33:48 +00:00
#else
FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
2014-06-09 15:33:48 +00:00
#endif
if (fd_ == -1)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot open file {}", path);
2014-06-09 15:33:48 +00:00
}
fmt::File::~File() FMT_NOEXCEPT(true) {
2014-06-09 15:33:48 +00:00
// Don't retry close in case of EINTR!
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
fmt::report_system_error(errno, "cannot close file");
2014-06-09 15:33:48 +00:00
}
void fmt::File::close() {
2014-06-09 15:33:48 +00:00
if (fd_ == -1)
return;
// Don't retry close in case of EINTR!
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
int result = FMT_POSIX_CALL(close(fd_));
fd_ = -1;
if (result != 0)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot close file");
2014-06-09 15:33:48 +00:00
}
fmt::LongLong fmt::File::size() const {
#ifdef _WIN32
LARGE_INTEGER size = {};
2014-09-12 19:37:32 +00:00
HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
if (!FMT_SYSTEM(GetFileSizeEx(handle, &size)))
throw WindowsError(GetLastError(), "cannot get file size");
FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(size.QuadPart),
"return type of File::size is not large enough");
return size.QuadPart;
#else
typedef struct stat Stat;
Stat file_stat = Stat();
if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
throw SystemError(errno, "cannot get file attributes");
FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size),
"return type of File::size is not large enough");
return file_stat.st_size;
#endif
}
std::size_t fmt::File::read(void *buffer, std::size_t count) {
RWResult result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
if (result < 0)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot read from file");
2014-06-09 15:33:48 +00:00
return result;
}
std::size_t fmt::File::write(const void *buffer, std::size_t count) {
RWResult result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
if (result < 0)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot write to file");
2014-06-09 15:33:48 +00:00
return result;
}
fmt::File fmt::File::dup(int fd) {
2014-06-09 15:33:48 +00:00
// Don't retry as dup doesn't return EINTR.
// http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
int new_fd = FMT_POSIX_CALL(dup(fd));
if (new_fd == -1)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot duplicate file descriptor {}", fd);
2014-06-09 15:33:48 +00:00
return File(new_fd);
}
void fmt::File::dup2(int fd) {
2014-06-09 15:33:48 +00:00
int result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
if (result == -1) {
2014-06-30 21:26:29 +00:00
throw SystemError(errno,
"cannot duplicate file descriptor {} to {}", fd_, fd);
2014-06-09 15:33:48 +00:00
}
}
void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT(true) {
2014-06-09 15:33:48 +00:00
int result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
if (result == -1)
ec = ErrorCode(errno);
}
void fmt::File::pipe(File &read_end, File &write_end) {
2014-06-09 15:33:48 +00:00
// Close the descriptors first to make sure that assignments don't throw
// and there are no leaks.
read_end.close();
write_end.close();
int fds[2] = {};
#ifdef _WIN32
// Make the default pipe capacity same as on Linux 2.6.11+.
enum { DEFAULT_CAPACITY = 65536 };
int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
#else
// Don't retry as the pipe function doesn't return EINTR.
// http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
int result = FMT_POSIX_CALL(pipe(fds));
#endif
if (result != 0)
2014-06-30 21:26:29 +00:00
throw SystemError(errno, "cannot create pipe");
2014-06-09 15:33:48 +00:00
// The following assignments don't throw because read_fd and write_fd
// are closed.
read_end = File(fds[0]);
write_end = File(fds[1]);
}
fmt::BufferedFile fmt::File::fdopen(const char *mode) {
2014-06-09 15:33:48 +00:00
// Don't retry as fdopen doesn't return EINTR.
FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
2014-06-30 21:26:29 +00:00
if (!f)
throw SystemError(errno, "cannot associate stream with file descriptor");
2014-06-09 15:33:48 +00:00
BufferedFile file(f);
fd_ = -1;
return file;
}
long fmt::getpagesize() {
#ifdef _WIN32
SYSTEM_INFO si = {};
GetSystemInfo(&si);
return si.dwPageSize;
#else
long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
if (size < 0)
throw SystemError(errno, "cannot get memory page size");
return size;
#endif
}