1 //===-- FileSystem.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Host/windows/windows.h"
11 
12 #include <shellapi.h>
13 #include <sys/stat.h>
14 #include <sys/types.h>
15 
16 #include "lldb/Host/FileSystem.h"
17 #include "lldb/Host/windows/AutoHandle.h"
18 
19 #include "llvm/Support/ConvertUTF.h"
20 #include "llvm/Support/FileSystem.h"
21 
22 using namespace lldb_private;
23 
24 const char *
25 FileSystem::DEV_NULL = "nul";
26 
27 const char *FileSystem::PATH_CONVERSION_ERROR = "Error converting path between UTF-8 and native encoding";
28 
29 FileSpec::PathSyntax
30 FileSystem::GetNativePathSyntax()
31 {
32     return FileSpec::ePathSyntaxWindows;
33 }
34 
35 Error
36 FileSystem::MakeDirectory(const FileSpec &file_spec, uint32_t file_permissions)
37 {
38     // On Win32, the mode parameter is ignored, as Windows files and directories support a
39     // different permission model than POSIX.
40     Error error;
41     const auto err_code = llvm::sys::fs::create_directories(file_spec.GetPath(), true);
42     if (err_code)
43     {
44         error.SetErrorString(err_code.message().c_str());
45     }
46 
47     return error;
48 }
49 
50 Error
51 FileSystem::DeleteDirectory(const FileSpec &file_spec, bool recurse)
52 {
53     Error error;
54     std::wstring path_buffer;
55     if (!llvm::ConvertUTF8toWide(file_spec.GetPath(), path_buffer))
56     {
57         error.SetErrorString(PATH_CONVERSION_ERROR);
58         return error;
59     }
60     if (!recurse)
61     {
62         BOOL result = ::RemoveDirectoryW(path_buffer.c_str());
63         if (!result)
64             error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
65     }
66     else
67     {
68         // SHFileOperation() accepts a list of paths, and so must be double-null-terminated to
69         // indicate the end of the list. The first null terminator is there only in the backing
70         // store but not the actual vector contents, and so we need to push twice.
71         path_buffer.push_back(0);
72         path_buffer.push_back(0);
73 
74         SHFILEOPSTRUCTW shfos = {0};
75         shfos.wFunc = FO_DELETE;
76         shfos.pFrom = (LPCWSTR)path_buffer.data();
77         shfos.fFlags = FOF_NO_UI;
78 
79         int result = ::SHFileOperationW(&shfos);
80         // TODO(zturner): Correctly handle the intricacies of SHFileOperation return values.
81         if (result != 0)
82             error.SetErrorStringWithFormat("SHFileOperation failed");
83     }
84     return error;
85 }
86 
87 Error
88 FileSystem::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
89 {
90     Error error;
91     // Beware that Windows's permission model is different from Unix's, and it's
92     // not clear if this API is supposed to check ACLs.  To match the caller's
93     // expectations as closely as possible, we'll use Microsoft's _stat, which
94     // attempts to emulate POSIX stat.  This should be good enough for basic
95     // checks like FileSpec::Readable.
96     struct _stat file_stats;
97     if (::_stat(file_spec.GetCString(), &file_stats) == 0)
98     {
99         // The owner permission bits in "st_mode" currently match the definitions
100         // for the owner file mode bits.
101         file_permissions = file_stats.st_mode & (_S_IREAD | _S_IWRITE | _S_IEXEC);
102     }
103     else
104     {
105         error.SetErrorToErrno();
106     }
107 
108     return error;
109 }
110 
111 Error
112 FileSystem::SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
113 {
114     Error error;
115     error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__);
116     return error;
117 }
118 
119 lldb::user_id_t
120 FileSystem::GetFileSize(const FileSpec &file_spec)
121 {
122     return file_spec.GetByteSize();
123 }
124 
125 bool
126 FileSystem::GetFileExists(const FileSpec &file_spec)
127 {
128     return file_spec.Exists();
129 }
130 
131 Error
132 FileSystem::Hardlink(const FileSpec &src, const FileSpec &dst)
133 {
134     Error error;
135     std::wstring wsrc, wdst;
136     if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) || !llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
137         error.SetErrorString(PATH_CONVERSION_ERROR);
138     else if (!::CreateHardLinkW(wsrc.c_str(), wdst.c_str(), nullptr))
139         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
140     return error;
141 }
142 
143 int
144 FileSystem::GetHardlinkCount(const FileSpec &file_spec)
145 {
146     std::wstring path;
147     if (!llvm::ConvertUTF8toWide(file_spec.GetCString(), path))
148         return -1;
149 
150     HANDLE file_handle = ::CreateFileW(path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
151                                        FILE_ATTRIBUTE_NORMAL, nullptr);
152 
153     if (file_handle == INVALID_HANDLE_VALUE)
154       return -1;
155 
156     AutoHandle auto_file_handle(file_handle);
157     BY_HANDLE_FILE_INFORMATION file_info;
158     if (::GetFileInformationByHandle(file_handle, &file_info))
159         return file_info.nNumberOfLinks;
160 
161     return -1;
162 }
163 
164 Error
165 FileSystem::Symlink(const FileSpec &src, const FileSpec &dst)
166 {
167     Error error;
168     std::wstring wsrc, wdst;
169     if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) || !llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
170         error.SetErrorString(PATH_CONVERSION_ERROR);
171     if (error.Fail())
172         return error;
173     DWORD attrib = ::GetFileAttributesW(wdst.c_str());
174     if (attrib == INVALID_FILE_ATTRIBUTES)
175     {
176         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
177         return error;
178     }
179     bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
180     DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
181     BOOL result = ::CreateSymbolicLinkW(wsrc.c_str(), wdst.c_str(), flag);
182     if (!result)
183         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
184     return error;
185 }
186 
187 Error
188 FileSystem::Unlink(const FileSpec &file_spec)
189 {
190     Error error;
191     std::wstring path;
192     if (!llvm::ConvertUTF8toWide(file_spec.GetCString(), path))
193     {
194         error.SetErrorString(PATH_CONVERSION_ERROR);
195         return error;
196     }
197     BOOL result = ::DeleteFileW(path.c_str());
198     if (!result)
199         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
200     return error;
201 }
202 
203 Error
204 FileSystem::Readlink(const FileSpec &src, FileSpec &dst)
205 {
206     Error error;
207     std::wstring wsrc;
208     if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc))
209     {
210         error.SetErrorString(PATH_CONVERSION_ERROR);
211         return error;
212     }
213 
214     HANDLE h = ::CreateFileW(wsrc.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
215                              FILE_FLAG_OPEN_REPARSE_POINT, NULL);
216     if (h == INVALID_HANDLE_VALUE)
217     {
218         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
219         return error;
220     }
221 
222     std::vector<wchar_t> buf(PATH_MAX + 1);
223     // Subtract 1 from the path length since this function does not add a null terminator.
224     DWORD result = ::GetFinalPathNameByHandleW(h, buf.data(), buf.size() - 1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
225     std::string path;
226     if (result == 0)
227         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
228     else if (!llvm::convertWideToUTF8(buf.data(), path))
229         error.SetErrorString(PATH_CONVERSION_ERROR);
230     else
231         dst.SetFile(path, false);
232 
233     ::CloseHandle(h);
234     return error;
235 }
236 
237 Error
238 FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst)
239 {
240     return Error("ResolveSymbolicLink() isn't implemented on Windows");
241 }
242 
243 bool
244 FileSystem::IsLocal(const FileSpec &spec)
245 {
246     if (spec)
247     {
248         // TODO: return true if the file is on a locally mounted file system
249         return true;
250     }
251 
252     return false;
253 }
254 
255 FILE *
256 FileSystem::Fopen(const char *path, const char *mode)
257 {
258     std::wstring wpath, wmode;
259     if (!llvm::ConvertUTF8toWide(path, wpath))
260         return nullptr;
261     if (!llvm::ConvertUTF8toWide(mode, wmode))
262         return nullptr;
263     FILE *file;
264     if (_wfopen_s(&file, wpath.c_str(), wmode.c_str()) != 0)
265         return nullptr;
266     return file;
267 }
268 
269 int
270 FileSystem::Stat(const char *path, struct stat *stats)
271 {
272     std::wstring wpath;
273     if (!llvm::ConvertUTF8toWide(path, wpath))
274     {
275         errno = EINVAL;
276         return -EINVAL;
277     }
278     int stat_result;
279 #ifdef _USE_32BIT_TIME_T
280     struct _stat32 file_stats;
281     stat_result = ::_wstat32(wpath.c_str(), &file_stats);
282 #else
283     struct _stat64i32 file_stats;
284     stat_result = ::_wstat64i32(wpath.c_str(), &file_stats);
285 #endif
286     if (stat_result == 0)
287     {
288         static_assert(sizeof(struct stat) == sizeof(file_stats),
289                       "stat and _stat32/_stat64i32 must have the same layout");
290         *stats = *reinterpret_cast<struct stat *>(&file_stats);
291     }
292     return stat_result;
293 }
294