| 1 |
//===---- URI.h - File URIs with schemes -------------------------*- C++-*-===// |
| 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 |
#include "URI.h" |
| 10 |
#include "support/Logger.h" |
| 11 |
#include "llvm/ADT/StringExtras.h" |
| 12 |
#include "llvm/ADT/Twine.h" |
| 13 |
#include "llvm/Support/Error.h" |
| 14 |
#include "llvm/Support/Path.h" |
| 15 |
#include <algorithm> |
| 16 |
|
| 17 |
LLVM_INSTANTIATE_REGISTRY(clang::clangd::URISchemeRegistry) |
| 18 |
|
| 19 |
namespace clang { |
| 20 |
namespace clangd { |
| 21 |
namespace { |
| 22 |
|
| 23 |
bool isWindowsPath(llvm::StringRef Path) { |
| 24 |
return Path.size() > 1 && llvm::isAlpha(Path[0]) && Path[1] == ':'; |
| 25 |
} |
| 26 |
|
| 27 |
bool isNetworkPath(llvm::StringRef Path) { |
| 28 |
return Path.size() > 2 && Path[0] == Path[1] && |
| 29 |
llvm::sys::path::is_separator(Path[0]); |
| 30 |
} |
| 31 |
|
| 32 |
/// This manages file paths in the file system. All paths in the scheme |
| 33 |
/// are absolute (with leading '/'). |
| 34 |
/// Note that this scheme is hardcoded into the library and not registered in |
| 35 |
/// registry. |
| 36 |
class FileSystemScheme : public URIScheme { |
| 37 |
public: |
| 38 |
llvm::Expected<std::string> |
| 39 |
getAbsolutePath(llvm::StringRef Authority, llvm::StringRef Body, |
| 40 |
llvm::StringRef /*HintPath*/) const override { |
| 41 |
if (!Body.startswith("/")) |
| 42 |
return error("File scheme: expect body to be an absolute path starting " |
| 43 |
"with '/': {0}", |
| 44 |
Body); |
| 45 |
llvm::SmallString<128> Path; |
| 46 |
if (!Authority.empty()) { |
| 47 |
// Windows UNC paths e.g. file://server/share => \\server\share |
| 48 |
("//" + Authority).toVector(Path); |
| 49 |
} else if (isWindowsPath(Body.substr(1))) { |
| 50 |
// Windows paths e.g. file:///X:/path => X:\path |
| 51 |
Body.consume_front("/"); |
| 52 |
} |
| 53 |
Path.append(Body); |
| 54 |
llvm::sys::path::native(Path); |
| 55 |
return std::string(Path); |
| 56 |
} |
| 57 |
|
| 58 |
llvm::Expected<URI> |
| 59 |
uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override { |
| 60 |
std::string Body; |
| 61 |
llvm::StringRef Authority; |
| 62 |
llvm::StringRef Root = llvm::sys::path::root_name(AbsolutePath); |
| 63 |
if (isNetworkPath(Root)) { |
| 64 |
// Windows UNC paths e.g. \\server\share => file://server/share |
| 65 |
Authority = Root.drop_front(2); |
| 66 |
AbsolutePath.consume_front(Root); |
| 67 |
} else if (isWindowsPath(Root)) { |
| 68 |
// Windows paths e.g. X:\path => file:///X:/path |
| 69 |
Body = "/"; |
| 70 |
} |
| 71 |
Body += llvm::sys::path::convert_to_slash(AbsolutePath); |
| 72 |
return URI("file", Authority, Body); |
| 73 |
} |
| 74 |
}; |
| 75 |
|
| 76 |
llvm::Expected<std::unique_ptr<URIScheme>> |
| 77 |
findSchemeByName(llvm::StringRef Scheme) { |
| 78 |
if (Scheme == "file") |
| 79 |
return std::make_unique<FileSystemScheme>(); |
| 80 |
|
| 81 |
for (const auto &URIScheme : URISchemeRegistry::entries()) { |
| 82 |
if (URIScheme.getName() != Scheme) |
| 83 |
continue; |
| 84 |
return URIScheme.instantiate(); |
| 85 |
} |
| 86 |
return error("Can't find scheme: {0}", Scheme); |
| 87 |
} |
| 88 |
|
| 89 |
bool shouldEscape(unsigned char C) { |
| 90 |
// Unreserved characters. |
| 91 |
if ((C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z') || |
| 92 |
(C >= '0' && C <= '9')) |
| 93 |
return false; |
| 94 |
switch (C) { |
| 95 |
case '-': |
| 96 |
case '_': |
| 97 |
case '.': |
| 98 |
case '~': |
| 99 |
case '/': // '/' is only reserved when parsing. |
| 100 |
// ':' is only reserved for relative URI paths, which clangd doesn't produce. |
| 101 |
case ':': |
| 102 |
return false; |
| 103 |
} |
| 104 |
return true; |
| 105 |
} |
| 106 |
|
| 107 |
/// Encodes a string according to percent-encoding. |
| 108 |
/// - Unreserved characters are not escaped. |
| 109 |
/// - Reserved characters always escaped with exceptions like '/'. |
| 110 |
/// - All other characters are escaped. |
| 111 |
void percentEncode(llvm::StringRef Content, std::string &Out) { |
| 112 |
for (unsigned char C : Content) |
| 113 |
if (shouldEscape(C)) { |
| 114 |
Out.push_back('%'); |
| 115 |
Out.push_back(llvm::hexdigit(C / 16)); |
| 116 |
Out.push_back(llvm::hexdigit(C % 16)); |
| 117 |
} else { |
| 118 |
Out.push_back(C); |
| 119 |
} |
| 120 |
} |
| 121 |
|
| 122 |
/// Decodes a string according to percent-encoding. |
| 123 |
std::string percentDecode(llvm::StringRef Content) { |
| 124 |
std::string Result; |
| 125 |
for (auto I = Content.begin(), E = Content.end(); I != E; ++I) { |
| 126 |
if (*I != '%') { |
| 127 |
Result += *I; |
| 128 |
continue; |
| 129 |
} |
| 130 |
if (*I == '%' && I + 2 < Content.end() && llvm::isHexDigit(*(I + 1)) && |
| 131 |
llvm::isHexDigit(*(I + 2))) { |
| 132 |
Result.push_back(llvm::hexFromNibbles(*(I + 1), *(I + 2))); |
| 133 |
I += 2; |
| 134 |
} else |
| 135 |
Result.push_back(*I); |
| 136 |
} |
| 137 |
return Result; |
| 138 |
} |
| 139 |
|
| 140 |
bool isValidScheme(llvm::StringRef Scheme) { |
| 141 |
if (Scheme.empty()) |
| 142 |
return false; |
| 143 |
if (!llvm::isAlpha(Scheme[0])) |
| 144 |
return false; |
| 145 |
return llvm::all_of(llvm::drop_begin(Scheme), [](char C) { |
| 146 |
return llvm::isAlnum(C) || C == '+' || C == '.' || C == '-'; |
| 147 |
}); |
| 148 |
} |
| 149 |
|
| 150 |
} // namespace |
| 151 |
|
| 152 |
URI::URI(llvm::StringRef Scheme, llvm::StringRef Authority, |
| 153 |
llvm::StringRef Body) |
| 154 |
: Scheme(Scheme), Authority(Authority), Body(Body) { |
| 155 |
assert(!Scheme.empty()); |
| 156 |
assert((Authority.empty() || Body.startswith("/")) && |
| 157 |
"URI body must start with '/' when authority is present."); |
| 158 |
} |
| 159 |
|
| 160 |
std::string URI::toString() const { |
| 161 |
std::string Result; |
| 162 |
percentEncode(Scheme, Result); |
| 163 |
Result.push_back(':'); |
| 164 |
if (Authority.empty() && Body.empty()) |
| 165 |
return Result; |
| 166 |
// If authority if empty, we only print body if it starts with "/"; otherwise, |
| 167 |
// the URI is invalid. |
| 168 |
if (!Authority.empty() || llvm::StringRef(Body).startswith("/")) |
| 169 |
{ |
| 170 |
Result.append("//"); |
| 171 |
percentEncode(Authority, Result); |
| 172 |
} |
| 173 |
percentEncode(Body, Result); |
| 174 |
return Result; |
| 175 |
} |
| 176 |
|
| 177 |
llvm::Expected<URI> URI::parse(llvm::StringRef OrigUri) { |
| 178 |
URI U; |
| 179 |
llvm::StringRef Uri = OrigUri; |
| 180 |
|
| 181 |
auto Pos = Uri.find(':'); |
| 182 |
if (Pos == llvm::StringRef::npos) |
| 183 |
return error("Scheme must be provided in URI: {0}", OrigUri); |
| 184 |
auto SchemeStr = Uri.substr(0, Pos); |
| 185 |
U.Scheme = percentDecode(SchemeStr); |
| 186 |
if (!isValidScheme(U.Scheme)) |
| 187 |
return error("Invalid scheme: {0} (decoded: {1})", SchemeStr, U.Scheme); |
| 188 |
Uri = Uri.substr(Pos + 1); |
| 189 |
if (Uri.consume_front("//")) { |
| 190 |
Pos = Uri.find('/'); |
| 191 |
U.Authority = percentDecode(Uri.substr(0, Pos)); |
| 192 |
Uri = Uri.substr(Pos); |
| 193 |
} |
| 194 |
U.Body = percentDecode(Uri); |
| 195 |
return U; |
| 196 |
} |
| 197 |
|
| 198 |
llvm::Expected<std::string> URI::resolve(llvm::StringRef FileURI, |
| 199 |
llvm::StringRef HintPath) { |
| 200 |
auto Uri = URI::parse(FileURI); |
| 201 |
if (!Uri) |
| 202 |
return Uri.takeError(); |
| 203 |
auto Path = URI::resolve(*Uri, HintPath); |
| 204 |
if (!Path) |
| 205 |
return Path.takeError(); |
| 206 |
return *Path; |
| 207 |
} |
| 208 |
|
| 209 |
llvm::Expected<URI> URI::create(llvm::StringRef AbsolutePath, |
| 210 |
llvm::StringRef Scheme) { |
| 211 |
if (!llvm::sys::path::is_absolute(AbsolutePath)) |
| 212 |
return error("Not a valid absolute path: {0}", AbsolutePath); |
| 213 |
auto S = findSchemeByName(Scheme); |
| 214 |
if (!S) |
| 215 |
return S.takeError(); |
| 216 |
return S->get()->uriFromAbsolutePath(AbsolutePath); |
| 217 |
} |
| 218 |
|
| 219 |
URI URI::create(llvm::StringRef AbsolutePath) { |
| 220 |
if (!llvm::sys::path::is_absolute(AbsolutePath)) |
| 221 |
llvm_unreachable( |
| 222 |
("Not a valid absolute path: " + AbsolutePath).str().c_str()); |
| 223 |
for (auto &Entry : URISchemeRegistry::entries()) { |
| 224 |
auto URI = Entry.instantiate()->uriFromAbsolutePath(AbsolutePath); |
| 225 |
// For some paths, conversion to different URI schemes is impossible. These |
| 226 |
// should be just skipped. |
| 227 |
if (!URI) { |
| 228 |
// Ignore the error. |
| 229 |
llvm::consumeError(URI.takeError()); |
| 230 |
continue; |
| 231 |
} |
| 232 |
return std::move(*URI); |
| 233 |
} |
| 234 |
// Fallback to file: scheme which should work for any paths. |
| 235 |
return URI::createFile(AbsolutePath); |
| 236 |
} |
| 237 |
|
| 238 |
URI URI::createFile(llvm::StringRef AbsolutePath) { |
| 239 |
auto U = FileSystemScheme().uriFromAbsolutePath(AbsolutePath); |
| 240 |
if (!U) |
| 241 |
llvm_unreachable(llvm::toString(U.takeError()).c_str()); |
| 242 |
return std::move(*U); |
| 243 |
} |
| 244 |
|
| 245 |
llvm::Expected<std::string> URI::resolve(const URI &Uri, |
| 246 |
llvm::StringRef HintPath) { |
| 247 |
auto S = findSchemeByName(Uri.Scheme); |
| 248 |
if (!S) |
| 249 |
return S.takeError(); |
| 250 |
return S->get()->getAbsolutePath(Uri.Authority, Uri.Body, HintPath); |
| 251 |
} |
| 252 |
|
| 253 |
llvm::Expected<std::string> URI::resolvePath(llvm::StringRef AbsPath, |
| 254 |
llvm::StringRef HintPath) { |
| 255 |
if (!llvm::sys::path::is_absolute(AbsPath)) |
| 256 |
llvm_unreachable(("Not a valid absolute path: " + AbsPath).str().c_str()); |
| 257 |
for (auto &Entry : URISchemeRegistry::entries()) { |
| 258 |
auto S = Entry.instantiate(); |
| 259 |
auto U = S->uriFromAbsolutePath(AbsPath); |
| 260 |
// For some paths, conversion to different URI schemes is impossible. These |
| 261 |
// should be just skipped. |
| 262 |
if (!U) { |
| 263 |
// Ignore the error. |
| 264 |
llvm::consumeError(U.takeError()); |
| 265 |
continue; |
| 266 |
} |
| 267 |
return S->getAbsolutePath(U->Authority, U->Body, HintPath); |
| 268 |
} |
| 269 |
// Fallback to file: scheme which doesn't do any canonicalization. |
| 270 |
return std::string(AbsPath); |
| 271 |
} |
| 272 |
|
| 273 |
llvm::Expected<std::string> URI::includeSpelling(const URI &Uri) { |
| 274 |
auto S = findSchemeByName(Uri.Scheme); |
| 275 |
if (!S) |
| 276 |
return S.takeError(); |
| 277 |
return S->get()->getIncludeSpelling(Uri); |
| 278 |
} |
| 279 |
|
| 280 |
} // namespace clangd |
| 281 |
} // namespace clang |