| 1 |
//===--- JSONTransport.cpp - sending and receiving LSP messages over JSON -===// |
| 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 |
#include "Protocol.h" // For LSPError |
| 9 |
#include "Transport.h" |
| 10 |
#include "support/Cancellation.h" |
| 11 |
#include "support/Logger.h" |
| 12 |
#include "support/Shutdown.h" |
| 13 |
#include "support/ThreadCrashReporter.h" |
| 14 |
#include "llvm/ADT/SmallString.h" |
| 15 |
#include "llvm/Support/Error.h" |
| 16 |
#include <optional> |
| 17 |
#include <system_error> |
| 18 |
|
| 19 |
namespace clang { |
| 20 |
namespace clangd { |
| 21 |
namespace { |
| 22 |
|
| 23 |
llvm::json::Object encodeError(llvm::Error E) { |
| 24 |
std::string Message; |
| 25 |
ErrorCode Code = ErrorCode::UnknownErrorCode; |
| 26 |
// FIXME: encode cancellation errors using RequestCancelled or ContentModified |
| 27 |
// as appropriate. |
| 28 |
if (llvm::Error Unhandled = llvm::handleErrors( |
| 29 |
std::move(E), |
| 30 |
[&](const CancelledError &C) -> llvm::Error { |
| 31 |
switch (C.Reason) { |
| 32 |
case static_cast<int>(ErrorCode::ContentModified): |
| 33 |
Code = ErrorCode::ContentModified; |
| 34 |
Message = "Request cancelled because the document was modified"; |
| 35 |
break; |
| 36 |
default: |
| 37 |
Code = ErrorCode::RequestCancelled; |
| 38 |
Message = "Request cancelled"; |
| 39 |
break; |
| 40 |
} |
| 41 |
return llvm::Error::success(); |
| 42 |
}, |
| 43 |
[&](const LSPError &L) -> llvm::Error { |
| 44 |
Message = L.Message; |
| 45 |
Code = L.Code; |
| 46 |
return llvm::Error::success(); |
| 47 |
})) |
| 48 |
Message = llvm::toString(std::move(Unhandled)); |
| 49 |
|
| 50 |
return llvm::json::Object{ |
| 51 |
{"message", std::move(Message)}, |
| 52 |
{"code", int64_t(Code)}, |
| 53 |
}; |
| 54 |
} |
| 55 |
|
| 56 |
llvm::Error decodeError(const llvm::json::Object &O) { |
| 57 |
llvm::StringRef Msg = O.getString("message").value_or("Unspecified error"); |
| 58 |
if (auto Code = O.getInteger("code")) |
| 59 |
return llvm::make_error<LSPError>(Msg.str(), ErrorCode(*Code)); |
| 60 |
return error(Msg.str()); |
| 61 |
} |
| 62 |
|
| 63 |
class JSONTransport : public Transport { |
| 64 |
public: |
| 65 |
JSONTransport(std::FILE *In, llvm::raw_ostream &Out, |
| 66 |
llvm::raw_ostream *InMirror, bool Pretty, JSONStreamStyle Style) |
| 67 |
: In(In), Out(Out), InMirror(InMirror ? *InMirror : llvm::nulls()), |
| 68 |
Pretty(Pretty), Style(Style) {} |
| 69 |
|
| 70 |
void notify(llvm::StringRef Method, llvm::json::Value Params) override { |
| 71 |
sendMessage(llvm::json::Object{ |
| 72 |
{"jsonrpc", "2.0"}, |
| 73 |
{"method", Method}, |
| 74 |
{"params", std::move(Params)}, |
| 75 |
}); |
| 76 |
} |
| 77 |
void call(llvm::StringRef Method, llvm::json::Value Params, |
| 78 |
llvm::json::Value ID) override { |
| 79 |
sendMessage(llvm::json::Object{ |
| 80 |
{"jsonrpc", "2.0"}, |
| 81 |
{"id", std::move(ID)}, |
| 82 |
{"method", Method}, |
| 83 |
{"params", std::move(Params)}, |
| 84 |
}); |
| 85 |
} |
| 86 |
void reply(llvm::json::Value ID, |
| 87 |
llvm::Expected<llvm::json::Value> Result) override { |
| 88 |
if (Result) { |
| 89 |
sendMessage(llvm::json::Object{ |
| 90 |
{"jsonrpc", "2.0"}, |
| 91 |
{"id", std::move(ID)}, |
| 92 |
{"result", std::move(*Result)}, |
| 93 |
}); |
| 94 |
} else { |
| 95 |
sendMessage(llvm::json::Object{ |
| 96 |
{"jsonrpc", "2.0"}, |
| 97 |
{"id", std::move(ID)}, |
| 98 |
{"error", encodeError(Result.takeError())}, |
| 99 |
}); |
| 100 |
} |
| 101 |
} |
| 102 |
|
| 103 |
llvm::Error loop(MessageHandler &Handler) override { |
| 104 |
std::string JSON; // Messages may be large, reuse same big buffer. |
| 105 |
while (!feof(In)) { |
| 106 |
if (shutdownRequested()) |
| 107 |
return error(std::make_error_code(std::errc::operation_canceled), |
| 108 |
"Got signal, shutting down"); |
| 109 |
if (ferror(In)) |
| 110 |
return llvm::errorCodeToError( |
| 111 |
std::error_code(errno, std::system_category())); |
| 112 |
if (readRawMessage(JSON)) { |
| 113 |
ThreadCrashReporter ScopedReporter([&JSON]() { |
| 114 |
auto &OS = llvm::errs(); |
| 115 |
OS << "Signalled while processing message:\n"; |
| 116 |
OS << JSON << "\n"; |
| 117 |
}); |
| 118 |
if (auto Doc = llvm::json::parse(JSON)) { |
| 119 |
vlog(Pretty ? "<<< {0:2}\n" : "<<< {0}\n", *Doc); |
| 120 |
if (!handleMessage(std::move(*Doc), Handler)) |
| 121 |
return llvm::Error::success(); // we saw the "exit" notification. |
| 122 |
} else { |
| 123 |
// Parse error. Log the raw message. |
| 124 |
vlog("<<< {0}\n", JSON); |
| 125 |
elog("JSON parse error: {0}", llvm::toString(Doc.takeError())); |
| 126 |
} |
| 127 |
} |
| 128 |
} |
| 129 |
return llvm::errorCodeToError(std::make_error_code(std::errc::io_error)); |
| 130 |
} |
| 131 |
|
| 132 |
private: |
| 133 |
// Dispatches incoming message to Handler onNotify/onCall/onReply. |
| 134 |
bool handleMessage(llvm::json::Value Message, MessageHandler &Handler); |
| 135 |
// Writes outgoing message to Out stream. |
| 136 |
void sendMessage(llvm::json::Value Message) { |
| 137 |
OutputBuffer.clear(); |
| 138 |
llvm::raw_svector_ostream OS(OutputBuffer); |
| 139 |
OS << llvm::formatv(Pretty ? "{0:2}" : "{0}", Message); |
| 140 |
Out << "Content-Length: " << OutputBuffer.size() << "\r\n\r\n" |
| 141 |
<< OutputBuffer; |
| 142 |
Out.flush(); |
| 143 |
vlog(">>> {0}\n", OutputBuffer); |
| 144 |
} |
| 145 |
|
| 146 |
// Read raw string messages from input stream. |
| 147 |
bool readRawMessage(std::string &JSON) { |
| 148 |
return Style == JSONStreamStyle::Delimited ? readDelimitedMessage(JSON) |
| 149 |
: readStandardMessage(JSON); |
| 150 |
} |
| 151 |
bool readDelimitedMessage(std::string &JSON); |
| 152 |
bool readStandardMessage(std::string &JSON); |
| 153 |
|
| 154 |
llvm::SmallVector<char, 0> OutputBuffer; |
| 155 |
std::FILE *In; |
| 156 |
llvm::raw_ostream &Out; |
| 157 |
llvm::raw_ostream &InMirror; |
| 158 |
bool Pretty; |
| 159 |
JSONStreamStyle Style; |
| 160 |
}; |
| 161 |
|
| 162 |
bool JSONTransport::handleMessage(llvm::json::Value Message, |
| 163 |
MessageHandler &Handler) { |
| 164 |
// Message must be an object with "jsonrpc":"2.0". |
| 165 |
auto *Object = Message.getAsObject(); |
| 166 |
if (!Object || |
| 167 |
Object->getString("jsonrpc") != std::optional<llvm::StringRef>("2.0")) { |
| 168 |
elog("Not a JSON-RPC 2.0 message: {0:2}", Message); |
| 169 |
return false; |
| 170 |
} |
| 171 |
// ID may be any JSON value. If absent, this is a notification. |
| 172 |
std::optional<llvm::json::Value> ID; |
| 173 |
if (auto *I = Object->get("id")) |
| 174 |
ID = std::move(*I); |
| 175 |
auto Method = Object->getString("method"); |
| 176 |
if (!Method) { // This is a response. |
| 177 |
if (!ID) { |
| 178 |
elog("No method and no response ID: {0:2}", Message); |
| 179 |
return false; |
| 180 |
} |
| 181 |
if (auto *Err = Object->getObject("error")) |
| 182 |
return Handler.onReply(std::move(*ID), decodeError(*Err)); |
| 183 |
// Result should be given, use null if not. |
| 184 |
llvm::json::Value Result = nullptr; |
| 185 |
if (auto *R = Object->get("result")) |
| 186 |
Result = std::move(*R); |
| 187 |
return Handler.onReply(std::move(*ID), std::move(Result)); |
| 188 |
} |
| 189 |
// Params should be given, use null if not. |
| 190 |
llvm::json::Value Params = nullptr; |
| 191 |
if (auto *P = Object->get("params")) |
| 192 |
Params = std::move(*P); |
| 193 |
|
| 194 |
if (ID) |
| 195 |
return Handler.onCall(*Method, std::move(Params), std::move(*ID)); |
| 196 |
return Handler.onNotify(*Method, std::move(Params)); |
| 197 |
} |
| 198 |
|
| 199 |
// Tries to read a line up to and including \n. |
| 200 |
// If failing, feof(), ferror(), or shutdownRequested() will be set. |
| 201 |
bool readLine(std::FILE *In, llvm::SmallVectorImpl<char> &Out) { |
| 202 |
// Big enough to hold any reasonable header line. May not fit content lines |
| 203 |
// in delimited mode, but performance doesn't matter for that mode. |
| 204 |
static constexpr int BufSize = 128; |
| 205 |
size_t Size = 0; |
| 206 |
Out.clear(); |
| 207 |
for (;;) { |
| 208 |
Out.resize_for_overwrite(Size + BufSize); |
| 209 |
// Handle EINTR which is sent when a debugger attaches on some platforms. |
| 210 |
if (!retryAfterSignalUnlessShutdown( |
| 211 |
nullptr, [&] { return std::fgets(&Out[Size], BufSize, In); })) |
| 212 |
return false; |
| 213 |
clearerr(In); |
| 214 |
// If the line contained null bytes, anything after it (including \n) will |
| 215 |
// be ignored. Fortunately this is not a legal header or JSON. |
| 216 |
size_t Read = std::strlen(&Out[Size]); |
| 217 |
if (Read > 0 && Out[Size + Read - 1] == '\n') { |
| 218 |
Out.resize(Size + Read); |
| 219 |
return true; |
| 220 |
} |
| 221 |
Size += Read; |
| 222 |
} |
| 223 |
} |
| 224 |
|
| 225 |
// Returns None when: |
| 226 |
// - ferror(), feof(), or shutdownRequested() are set. |
| 227 |
// - Content-Length is missing or empty (protocol error) |
| 228 |
bool JSONTransport::readStandardMessage(std::string &JSON) { |
| 229 |
// A Language Server Protocol message starts with a set of HTTP headers, |
| 230 |
// delimited by \r\n, and terminated by an empty line (\r\n). |
| 231 |
unsigned long long ContentLength = 0; |
| 232 |
llvm::SmallString<128> Line; |
| 233 |
while (true) { |
| 234 |
if (feof(In) || ferror(In) || !readLine(In, Line)) |
| 235 |
return false; |
| 236 |
InMirror << Line; |
| 237 |
|
| 238 |
llvm::StringRef LineRef = Line; |
| 239 |
|
| 240 |
// We allow comments in headers. Technically this isn't part |
| 241 |
|
| 242 |
// of the LSP specification, but makes writing tests easier. |
| 243 |
if (LineRef.startswith("#")) |
| 244 |
continue; |
| 245 |
|
| 246 |
// Content-Length is a mandatory header, and the only one we handle. |
| 247 |
if (LineRef.consume_front("Content-Length: ")) { |
| 248 |
if (ContentLength != 0) { |
| 249 |
elog("Warning: Duplicate Content-Length header received. " |
| 250 |
"The previous value for this message ({0}) was ignored.", |
| 251 |
ContentLength); |
| 252 |
} |
| 253 |
llvm::getAsUnsignedInteger(LineRef.trim(), 0, ContentLength); |
| 254 |
continue; |
| 255 |
} |
| 256 |
|
| 257 |
// An empty line indicates the end of headers. |
| 258 |
// Go ahead and read the JSON. |
| 259 |
if (LineRef.trim().empty()) |
| 260 |
break; |
| 261 |
|
| 262 |
// It's another header, ignore it. |
| 263 |
} |
| 264 |
|
| 265 |
// The fuzzer likes crashing us by sending "Content-Length: 9999999999999999" |
| 266 |
if (ContentLength > 1 << 30) { // 1024M |
| 267 |
elog("Refusing to read message with long Content-Length: {0}. " |
| 268 |
"Expect protocol errors", |
| 269 |
ContentLength); |
| 270 |
return false; |
| 271 |
} |
| 272 |
if (ContentLength == 0) { |
| 273 |
log("Warning: Missing Content-Length header, or zero-length message."); |
| 274 |
return false; |
| 275 |
} |
| 276 |
|
| 277 |
JSON.resize(ContentLength); |
| 278 |
for (size_t Pos = 0, Read; Pos < ContentLength; Pos += Read) { |
| 279 |
// Handle EINTR which is sent when a debugger attaches on some platforms. |
| 280 |
Read = retryAfterSignalUnlessShutdown(0, [&]{ |
| 281 |
return std::fread(&JSON[Pos], 1, ContentLength - Pos, In); |
| 282 |
}); |
| 283 |
if (Read == 0) { |
| 284 |
elog("Input was aborted. Read only {0} bytes of expected {1}.", Pos, |
| 285 |
ContentLength); |
| 286 |
return false; |
| 287 |
} |
| 288 |
InMirror << llvm::StringRef(&JSON[Pos], Read); |
| 289 |
clearerr(In); // If we're done, the error was transient. If we're not done, |
| 290 |
// either it was transient or we'll see it again on retry. |
| 291 |
Pos += Read; |
| 292 |
} |
| 293 |
return true; |
| 294 |
} |
| 295 |
|
| 296 |
// For lit tests we support a simplified syntax: |
| 297 |
// - messages are delimited by '---' on a line by itself |
| 298 |
// - lines starting with # are ignored. |
| 299 |
// This is a testing path, so favor simplicity over performance here. |
| 300 |
// When returning false: feof(), ferror(), or shutdownRequested() will be set. |
| 301 |
bool JSONTransport::readDelimitedMessage(std::string &JSON) { |
| 302 |
JSON.clear(); |
| 303 |
llvm::SmallString<128> Line; |
| 304 |
while (readLine(In, Line)) { |
| 305 |
InMirror << Line; |
| 306 |
auto LineRef = Line.str().trim(); |
| 307 |
if (LineRef.startswith("#")) // comment |
| 308 |
continue; |
| 309 |
|
| 310 |
// found a delimiter |
| 311 |
if (LineRef.rtrim() == "---") |
| 312 |
break; |
| 313 |
|
| 314 |
JSON += Line; |
| 315 |
} |
| 316 |
|
| 317 |
if (shutdownRequested()) |
| 318 |
return false; |
| 319 |
if (ferror(In)) { |
| 320 |
elog("Input error while reading message!"); |
| 321 |
return false; |
| 322 |
} |
| 323 |
return true; // Including at EOF |
| 324 |
} |
| 325 |
|
| 326 |
} // namespace |
| 327 |
|
| 328 |
std::unique_ptr<Transport> newJSONTransport(std::FILE *In, |
| 329 |
llvm::raw_ostream &Out, |
| 330 |
llvm::raw_ostream *InMirror, |
| 331 |
bool Pretty, |
| 332 |
JSONStreamStyle Style) { |
| 333 |
return std::make_unique<JSONTransport>(In, Out, InMirror, Pretty, Style); |
| 334 |
} |
| 335 |
|
| 336 |
} // namespace clangd |
| 337 |
} // namespace clang |