os.cc
1 // Formatting library for C++ - optional OS-specific functionality 2 // 3 // Copyright (c) 2012 - 2016, Victor Zverovich 4 // All rights reserved. 5 // 6 // For the license information refer to format.h. 7 8 // Disable bogus MSVC warnings. 9 #if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER) 10 # define _CRT_SECURE_NO_WARNINGS 11 #endif 12 13 #include "fmt/os.h" 14 15 #include <climits> 16 17 #if FMT_USE_FCNTL 18 # include <sys/stat.h> 19 # include <sys/types.h> 20 21 # ifdef _WRS_KERNEL // VxWorks7 kernel 22 # include <ioLib.h> // getpagesize 23 # endif 24 25 # ifndef _WIN32 26 # include <unistd.h> 27 # else 28 # ifndef WIN32_LEAN_AND_MEAN 29 # define WIN32_LEAN_AND_MEAN 30 # endif 31 # include <io.h> 32 33 # ifndef S_IRUSR 34 # define S_IRUSR _S_IREAD 35 # endif 36 # ifndef S_IWUSR 37 # define S_IWUSR _S_IWRITE 38 # endif 39 # ifndef S_IRGRP 40 # define S_IRGRP 0 41 # endif 42 # ifndef S_IWGRP 43 # define S_IWGRP 0 44 # endif 45 # ifndef S_IROTH 46 # define S_IROTH 0 47 # endif 48 # ifndef S_IWOTH 49 # define S_IWOTH 0 50 # endif 51 # endif // _WIN32 52 #endif // FMT_USE_FCNTL 53 54 #ifdef _WIN32 55 # include <windows.h> 56 #endif 57 58 namespace { 59 #ifdef _WIN32 60 // Return type of read and write functions. 61 using rwresult = int; 62 63 // On Windows the count argument to read and write is unsigned, so convert 64 // it from size_t preventing integer overflow. 65 inline unsigned convert_rwcount(std::size_t count) { 66 return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX; 67 } 68 #elif FMT_USE_FCNTL 69 // Return type of read and write functions. 70 using rwresult = ssize_t; 71 72 inline std::size_t convert_rwcount(std::size_t count) { return count; } 73 #endif 74 } // namespace 75 76 FMT_BEGIN_NAMESPACE 77 78 #ifdef _WIN32 79 namespace detail { 80 81 class system_message { 82 system_message(const system_message&) = delete; 83 void operator=(const system_message&) = delete; 84 85 unsigned long result_; 86 wchar_t* message_; 87 88 static bool is_whitespace(wchar_t c) noexcept { 89 return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0'; 90 } 91 92 public: 93 explicit system_message(unsigned long error_code) 94 : result_(0), message_(nullptr) { 95 result_ = FormatMessageW( 96 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | 97 FORMAT_MESSAGE_IGNORE_INSERTS, 98 nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 99 reinterpret_cast<wchar_t*>(&message_), 0, nullptr); 100 if (result_ != 0) { 101 while (result_ != 0 && is_whitespace(message_[result_ - 1])) { 102 --result_; 103 } 104 } 105 } 106 ~system_message() { LocalFree(message_); } 107 explicit operator bool() const noexcept { return result_ != 0; } 108 operator basic_string_view<wchar_t>() const noexcept { 109 return basic_string_view<wchar_t>(message_, result_); 110 } 111 }; 112 113 class utf8_system_category final : public std::error_category { 114 public: 115 const char* name() const noexcept override { return "system"; } 116 std::string message(int error_code) const override { 117 auto&& msg = system_message(error_code); 118 if (msg) { 119 auto utf8_message = to_utf8<wchar_t>(); 120 if (utf8_message.convert(msg)) { 121 return utf8_message.str(); 122 } 123 } 124 return "unknown error"; 125 } 126 }; 127 128 } // namespace detail 129 130 FMT_API const std::error_category& system_category() noexcept { 131 static const detail::utf8_system_category category; 132 return category; 133 } 134 135 std::system_error vwindows_error(int err_code, string_view format_str, 136 format_args args) { 137 auto ec = std::error_code(err_code, system_category()); 138 return std::system_error(ec, vformat(format_str, args)); 139 } 140 141 void detail::format_windows_error(detail::buffer<char>& out, int error_code, 142 const char* message) noexcept { 143 FMT_TRY { 144 auto&& msg = system_message(error_code); 145 if (msg) { 146 auto utf8_message = to_utf8<wchar_t>(); 147 if (utf8_message.convert(msg)) { 148 fmt::format_to(appender(out), FMT_STRING("{}: {}"), message, 149 string_view(utf8_message)); 150 return; 151 } 152 } 153 } 154 FMT_CATCH(...) {} 155 format_error_code(out, error_code, message); 156 } 157 158 void report_windows_error(int error_code, const char* message) noexcept { 159 report_error(detail::format_windows_error, error_code, message); 160 } 161 #endif // _WIN32 162 163 buffered_file::~buffered_file() noexcept { 164 if (file_ && FMT_SYSTEM(fclose(file_)) != 0) 165 report_system_error(errno, "cannot close file"); 166 } 167 168 buffered_file::buffered_file(cstring_view filename, cstring_view mode) { 169 FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 170 nullptr); 171 if (!file_) 172 FMT_THROW(system_error(errno, FMT_STRING("cannot open file {}"), 173 filename.c_str())); 174 } 175 176 void buffered_file::close() { 177 if (!file_) return; 178 int result = FMT_SYSTEM(fclose(file_)); 179 file_ = nullptr; 180 if (result != 0) 181 FMT_THROW(system_error(errno, FMT_STRING("cannot close file"))); 182 } 183 184 int buffered_file::descriptor() const { 185 #ifdef fileno // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL. 186 int fd = fileno(file_); 187 #else 188 int fd = FMT_POSIX_CALL(fileno(file_)); 189 #endif 190 if (fd == -1) 191 FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor"))); 192 return fd; 193 } 194 195 #if FMT_USE_FCNTL 196 # ifdef _WIN32 197 using mode_t = int; 198 # endif 199 constexpr mode_t default_open_mode = 200 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; 201 202 file::file(cstring_view path, int oflag) { 203 # if defined(_WIN32) && !defined(__MINGW32__) 204 fd_ = -1; 205 auto converted = detail::utf8_to_utf16(string_view(path.c_str())); 206 *this = file::open_windows_file(converted.c_str(), oflag); 207 # else 208 FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, default_open_mode))); 209 if (fd_ == -1) 210 FMT_THROW( 211 system_error(errno, FMT_STRING("cannot open file {}"), path.c_str())); 212 # endif 213 } 214 215 file::~file() noexcept { 216 // Don't retry close in case of EINTR! 217 // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html 218 if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0) 219 report_system_error(errno, "cannot close file"); 220 } 221 222 void file::close() { 223 if (fd_ == -1) return; 224 // Don't retry close in case of EINTR! 225 // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html 226 int result = FMT_POSIX_CALL(close(fd_)); 227 fd_ = -1; 228 if (result != 0) 229 FMT_THROW(system_error(errno, FMT_STRING("cannot close file"))); 230 } 231 232 long long file::size() const { 233 # ifdef _WIN32 234 // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT 235 // is less than 0x0500 as is the case with some default MinGW builds. 236 // Both functions support large file sizes. 237 DWORD size_upper = 0; 238 HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_)); 239 DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper)); 240 if (size_lower == INVALID_FILE_SIZE) { 241 DWORD error = GetLastError(); 242 if (error != NO_ERROR) 243 FMT_THROW(windows_error(GetLastError(), "cannot get file size")); 244 } 245 unsigned long long long_size = size_upper; 246 return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower; 247 # else 248 using Stat = struct stat; 249 Stat file_stat = Stat(); 250 if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1) 251 FMT_THROW(system_error(errno, FMT_STRING("cannot get file attributes"))); 252 static_assert(sizeof(long long) >= sizeof(file_stat.st_size), 253 "return type of file::size is not large enough"); 254 return file_stat.st_size; 255 # endif 256 } 257 258 std::size_t file::read(void* buffer, std::size_t count) { 259 rwresult result = 0; 260 FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count)))); 261 if (result < 0) 262 FMT_THROW(system_error(errno, FMT_STRING("cannot read from file"))); 263 return detail::to_unsigned(result); 264 } 265 266 std::size_t file::write(const void* buffer, std::size_t count) { 267 rwresult result = 0; 268 FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count)))); 269 if (result < 0) 270 FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); 271 return detail::to_unsigned(result); 272 } 273 274 file file::dup(int fd) { 275 // Don't retry as dup doesn't return EINTR. 276 // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html 277 int new_fd = FMT_POSIX_CALL(dup(fd)); 278 if (new_fd == -1) 279 FMT_THROW(system_error( 280 errno, FMT_STRING("cannot duplicate file descriptor {}"), fd)); 281 return file(new_fd); 282 } 283 284 void file::dup2(int fd) { 285 int result = 0; 286 FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd))); 287 if (result == -1) { 288 FMT_THROW(system_error( 289 errno, FMT_STRING("cannot duplicate file descriptor {} to {}"), fd_, 290 fd)); 291 } 292 } 293 294 void file::dup2(int fd, std::error_code& ec) noexcept { 295 int result = 0; 296 FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd))); 297 if (result == -1) ec = std::error_code(errno, std::generic_category()); 298 } 299 300 void file::pipe(file& read_end, file& write_end) { 301 // Close the descriptors first to make sure that assignments don't throw 302 // and there are no leaks. 303 read_end.close(); 304 write_end.close(); 305 int fds[2] = {}; 306 # ifdef _WIN32 307 // Make the default pipe capacity same as on Linux 2.6.11+. 308 enum { DEFAULT_CAPACITY = 65536 }; 309 int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY)); 310 # else 311 // Don't retry as the pipe function doesn't return EINTR. 312 // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html 313 int result = FMT_POSIX_CALL(pipe(fds)); 314 # endif 315 if (result != 0) 316 FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe"))); 317 // The following assignments don't throw because read_fd and write_fd 318 // are closed. 319 read_end = file(fds[0]); 320 write_end = file(fds[1]); 321 } 322 323 buffered_file file::fdopen(const char* mode) { 324 // Don't retry as fdopen doesn't return EINTR. 325 # if defined(__MINGW32__) && defined(_POSIX_) 326 FILE* f = ::fdopen(fd_, mode); 327 # else 328 FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode)); 329 # endif 330 if (!f) { 331 FMT_THROW(system_error( 332 errno, FMT_STRING("cannot associate stream with file descriptor"))); 333 } 334 buffered_file bf(f); 335 fd_ = -1; 336 return bf; 337 } 338 339 # if defined(_WIN32) && !defined(__MINGW32__) 340 file file::open_windows_file(wcstring_view path, int oflag) { 341 int fd = -1; 342 auto err = _wsopen_s(&fd, path.c_str(), oflag, _SH_DENYNO, default_open_mode); 343 if (fd == -1) { 344 FMT_THROW(system_error(err, FMT_STRING("cannot open file {}"), 345 detail::to_utf8<wchar_t>(path.c_str()).c_str())); 346 } 347 return file(fd); 348 } 349 # endif 350 351 # if !defined(__MSDOS__) 352 long getpagesize() { 353 # ifdef _WIN32 354 SYSTEM_INFO si; 355 GetSystemInfo(&si); 356 return si.dwPageSize; 357 # else 358 # ifdef _WRS_KERNEL 359 long size = FMT_POSIX_CALL(getpagesize()); 360 # else 361 long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE)); 362 # endif 363 364 if (size < 0) 365 FMT_THROW(system_error(errno, FMT_STRING("cannot get memory page size"))); 366 return size; 367 # endif 368 } 369 # endif 370 371 namespace detail { 372 373 void file_buffer::grow(size_t) { 374 if (this->size() == this->capacity()) flush(); 375 } 376 377 file_buffer::file_buffer(cstring_view path, 378 const detail::ostream_params& params) 379 : file_(path, params.oflag) { 380 set(new char[params.buffer_size], params.buffer_size); 381 } 382 383 file_buffer::file_buffer(file_buffer&& other) 384 : detail::buffer<char>(other.data(), other.size(), other.capacity()), 385 file_(std::move(other.file_)) { 386 other.clear(); 387 other.set(nullptr, 0); 388 } 389 390 file_buffer::~file_buffer() { 391 flush(); 392 delete[] data(); 393 } 394 } // namespace detail 395 396 ostream::~ostream() = default; 397 #endif // FMT_USE_FCNTL 398 FMT_END_NAMESPACE