1 //===----------------------------------------------------------------------===////
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===////
8 
9 #ifndef FILESYSTEM_ERROR_H
10 #define FILESYSTEM_ERROR_H
11 
12 #include <__assert>
13 #include <__config>
14 #include <cerrno>
15 #include <cstdarg>
16 #include <cstddef>
17 #include <cstdint>
18 #include <filesystem>
19 #include <string>
20 #include <system_error>
21 #include <utility> // __libcpp_unreachable
22 
23 #include "format_string.h"
24 
25 #if defined(_LIBCPP_WIN32API)
26 # define WIN32_LEAN_AND_MEAN
27 # define NOMINMAX
28 # include <windows.h> // ERROR_* macros
29 #endif
30 
31 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
32 
33 namespace detail {
34 
35 #if defined(_LIBCPP_WIN32API)
36 
37 inline errc __win_err_to_errc(int err) {
38   constexpr struct {
39     DWORD win;
40     errc errc;
41   } win_error_mapping[] = {
42       {ERROR_ACCESS_DENIED, errc::permission_denied},
43       {ERROR_ALREADY_EXISTS, errc::file_exists},
44       {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
45       {ERROR_BAD_PATHNAME, errc::no_such_file_or_directory},
46       {ERROR_BAD_UNIT, errc::no_such_device},
47       {ERROR_BROKEN_PIPE, errc::broken_pipe},
48       {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
49       {ERROR_BUSY, errc::device_or_resource_busy},
50       {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
51       {ERROR_CANNOT_MAKE, errc::permission_denied},
52       {ERROR_CANTOPEN, errc::io_error},
53       {ERROR_CANTREAD, errc::io_error},
54       {ERROR_CANTWRITE, errc::io_error},
55       {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
56       {ERROR_DEV_NOT_EXIST, errc::no_such_device},
57       {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
58       {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
59       {ERROR_DIRECTORY, errc::invalid_argument},
60       {ERROR_DISK_FULL, errc::no_space_on_device},
61       {ERROR_FILE_EXISTS, errc::file_exists},
62       {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
63       {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
64       {ERROR_INVALID_ACCESS, errc::permission_denied},
65       {ERROR_INVALID_DRIVE, errc::no_such_device},
66       {ERROR_INVALID_FUNCTION, errc::function_not_supported},
67       {ERROR_INVALID_HANDLE, errc::invalid_argument},
68       {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
69       {ERROR_INVALID_PARAMETER, errc::invalid_argument},
70       {ERROR_LOCK_VIOLATION, errc::no_lock_available},
71       {ERROR_LOCKED, errc::no_lock_available},
72       {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
73       {ERROR_NOACCESS, errc::permission_denied},
74       {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
75       {ERROR_NOT_READY, errc::resource_unavailable_try_again},
76       {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
77       {ERROR_NOT_SUPPORTED, errc::not_supported},
78       {ERROR_OPEN_FAILED, errc::io_error},
79       {ERROR_OPEN_FILES, errc::device_or_resource_busy},
80       {ERROR_OPERATION_ABORTED, errc::operation_canceled},
81       {ERROR_OUTOFMEMORY, errc::not_enough_memory},
82       {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
83       {ERROR_READ_FAULT, errc::io_error},
84       {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
85       {ERROR_RETRY, errc::resource_unavailable_try_again},
86       {ERROR_SEEK, errc::io_error},
87       {ERROR_SHARING_VIOLATION, errc::permission_denied},
88       {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
89       {ERROR_WRITE_FAULT, errc::io_error},
90       {ERROR_WRITE_PROTECT, errc::permission_denied},
91   };
92 
93   for (const auto &pair : win_error_mapping)
94     if (pair.win == static_cast<DWORD>(err))
95       return pair.errc;
96   return errc::invalid_argument;
97 }
98 
99 #endif // _LIBCPP_WIN32API
100 
101 inline error_code capture_errno() {
102   _LIBCPP_ASSERT_UNCATEGORIZED(errno != 0, "Expected errno to be non-zero");
103   return error_code(errno, generic_category());
104 }
105 
106 #if defined(_LIBCPP_WIN32API)
107 inline error_code make_windows_error(int err) {
108   return make_error_code(__win_err_to_errc(err));
109 }
110 #endif
111 
112 template <class T>
113 T error_value();
114 template <>
115 inline constexpr void error_value<void>() {}
116 template <>
117 inline bool error_value<bool>() {
118   return false;
119 }
120 #if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__
121 template <>
122 inline size_t error_value<size_t>() {
123   return size_t(-1);
124 }
125 #endif
126 template <>
127 inline uintmax_t error_value<uintmax_t>() {
128   return uintmax_t(-1);
129 }
130 template <>
131 inline constexpr file_time_type error_value<file_time_type>() {
132   return file_time_type::min();
133 }
134 template <>
135 inline path error_value<path>() {
136   return {};
137 }
138 
139 template <class T>
140 struct ErrorHandler {
141   const char* func_name_;
142   error_code* ec_ = nullptr;
143   const path* p1_ = nullptr;
144   const path* p2_ = nullptr;
145 
146   ErrorHandler(const char* fname, error_code* ec, const path* p1 = nullptr,
147                const path* p2 = nullptr)
148       : func_name_(fname), ec_(ec), p1_(p1), p2_(p2) {
149     if (ec_)
150       ec_->clear();
151   }
152 
153   T report(const error_code& ec) const {
154     if (ec_) {
155       *ec_ = ec;
156       return error_value<T>();
157     }
158     string what = string("in ") + func_name_;
159     switch (bool(p1_) + bool(p2_)) {
160     case 0:
161       __throw_filesystem_error(what, ec);
162     case 1:
163       __throw_filesystem_error(what, *p1_, ec);
164     case 2:
165       __throw_filesystem_error(what, *p1_, *p2_, ec);
166     }
167     __libcpp_unreachable();
168   }
169 
170   _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 0)
171   void report_impl(const error_code& ec, const char* msg, va_list ap) const {
172     if (ec_) {
173       *ec_ = ec;
174       return;
175     }
176     string what =
177         string("in ") + func_name_ + ": " + detail::vformat_string(msg, ap);
178     switch (bool(p1_) + bool(p2_)) {
179     case 0:
180       __throw_filesystem_error(what, ec);
181     case 1:
182       __throw_filesystem_error(what, *p1_, ec);
183     case 2:
184       __throw_filesystem_error(what, *p1_, *p2_, ec);
185     }
186     __libcpp_unreachable();
187   }
188 
189   _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
190   T report(const error_code& ec, const char* msg, ...) const {
191     va_list ap;
192     va_start(ap, msg);
193 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
194     try {
195 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
196       report_impl(ec, msg, ap);
197 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
198     } catch (...) {
199       va_end(ap);
200       throw;
201     }
202 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
203     va_end(ap);
204     return error_value<T>();
205   }
206 
207   T report(errc const& err) const {
208     return report(make_error_code(err));
209   }
210 
211   _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
212   T report(errc const& err, const char* msg, ...) const {
213     va_list ap;
214     va_start(ap, msg);
215 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
216     try {
217 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
218       report_impl(make_error_code(err), msg, ap);
219 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
220     } catch (...) {
221       va_end(ap);
222       throw;
223     }
224 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
225     va_end(ap);
226     return error_value<T>();
227   }
228 
229 private:
230   ErrorHandler(ErrorHandler const&) = delete;
231   ErrorHandler& operator=(ErrorHandler const&) = delete;
232 };
233 
234 } // end namespace detail
235 
236 _LIBCPP_END_NAMESPACE_FILESYSTEM
237 
238 #endif // FILESYSTEM_ERROR_H
239