[clangd] Check that scheme is valid when parsing URI.

[sammccall]

clangd/URI.cpp

134

nit: lowercase isValidScheme

[ioeric]

• lower case function name.

clangd/URI.cpp

 //===---- URI.h - File URIs with schemes -------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "URI.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
+#include <algorithm>
 #include <iomanip>
+#include <locale>
 #include <sstream>
 
 LLVM_INSTANTIATE_REGISTRY(clang::clangd::URISchemeRegistry)
 
 namespace clang {
 namespace clangd {
 namespace {
 
if (*I == '%' && I + 2 < Content.end() && llvm::isHexDigit(*(I + 1)) &&
       Result.push_back(llvm::hexFromNibbles(*(I + 1), *(I + 2)));
       I += 2;
     } else
       Result.push_back(*I);
   }
   return Result;
 }
 
+bool isValidScheme(llvm::StringRef Scheme) {
+  if (Scheme.empty())
+    return false;
+  if (!std::isalpha(Scheme[0]))
+    return false;
+  return std::all_of(Scheme.begin() + 1, Scheme.end(), [](char C) {
+    return std::isalpha(C) || std::isdigit(C) || C == '+' || C == '.' ||
+           C == '-';
+  });
+}
+
 } // namespace
 
 URI::URI(llvm::StringRef Scheme, llvm::StringRef Authority,
          llvm::StringRef Body)
     : Scheme(Scheme), Authority(Authority), Body(Body) {
   assert(!Scheme.empty());
   assert((Authority.empty() || Body.startswith("/")) &&
          "URI body must start with '/' when authority is present.");
std::string URI::toString() const {
   return Result;
 }
 
 llvm::Expected<URI> URI::parse(llvm::StringRef OrigUri) {
   URI U;
   llvm::StringRef Uri = OrigUri;
 
   auto Pos = Uri.find(':');
-  if (Pos == 0 || Pos == llvm::StringRef::npos)
+  if (Pos == llvm::StringRef::npos)
     return make_string_error("Scheme must be provided in URI: " + OrigUri);
-  U.Scheme = percentDecode(Uri.substr(0, Pos));
+  auto SchemeStr = Uri.substr(0, Pos);
+  U.Scheme = percentDecode(SchemeStr);
+  if (!isValidScheme(U.Scheme))
+    return make_string_error(llvm::formatv("Invalid scheme: {0} (decoded: {1})",
+                                           SchemeStr, U.Scheme));
   Uri = Uri.substr(Pos + 1);
   if (Uri.consume_front("//")) {
     Pos = Uri.find('/');
     U.Authority = percentDecode(Uri.substr(0, Pos));
     Uri = Uri.substr(Pos);
   }
   U.Body = percentDecode(Uri);
   return U;

unittests/clangd/URITests.cpp

TEST(PercentEncodingTest, Encode) {
   EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
   EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3bc~");
   EXPECT_EQ(URI("x", /*Authority=*/"", "a123b").toString(), "x:a123b");
 }
 
 TEST(PercentEncodingTest, Decode) {
   EXPECT_EQ(parseOrDie("x:a/b/c").body(), "a/b/c");
 
-  EXPECT_EQ(parseOrDie("%3a://%3a/%3").scheme(), ":");
-  EXPECT_EQ(parseOrDie("%3a://%3a/%3").authority(), ":");
-  EXPECT_EQ(parseOrDie("%3a://%3a/%3").body(), "/%3");
+  EXPECT_EQ(parseOrDie("s%2b://%3a/%3").scheme(), "s+");
+  EXPECT_EQ(parseOrDie("s%2b://%3a/%3").authority(), ":");
+  EXPECT_EQ(parseOrDie("s%2b://%3a/%3").body(), "/%3");
 
   EXPECT_EQ(parseOrDie("x:a%21b%3ac~").body(), "a!b:c~");
 }
 
 std::string resolveOrDie(const URI &U, llvm::StringRef HintPath = "") {
   auto Path = URI::resolve(U, HintPath);
   if (!Path)
     llvm_unreachable(llvm::toString(Path.takeError()).c_str());
auto FailedParse = [](llvm::StringRef U) {
     return false;
   };
 
   // Expect ':' in URI.
   EXPECT_TRUE(FailedParse("file//x/y/z"));
   // Empty.
   EXPECT_TRUE(FailedParse(""));
   EXPECT_TRUE(FailedParse(":/a/b/c"));
+  EXPECT_TRUE(FailedParse("\"/a/b/c\" IWYU pragma: abc"));
 }
 
 TEST(URITest, Resolve) {
 #ifdef _WIN32
   EXPECT_THAT(resolveOrDie(parseOrDie("file:///c%3a/x/y/z")), "c:\\x\\y\\z");
 #else
   EXPECT_EQ(resolveOrDie(parseOrDie("file:/a/b/c")), "/a/b/c");
   EXPECT_EQ(resolveOrDie(parseOrDie("file://auth/a/b/c")), "/a/b/c");