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
19namespace clang {
20namespace clangd {
21namespace {
22
23llvm::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 E: std::move(E),
30 Hs: [&](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 Hs: [&](const LSPError &L) -> llvm::Error {
44 Message = L.Message;
45 Code = L.Code;
46 return llvm::Error::success();
47 }))
48 Message = llvm::toString(E: std::move(Unhandled));
49
50 return llvm::json::Object{
51 {.K: "message", .V: std::move(Message)},
52 {.K: "code", .V: int64_t(Code)},
53 };
54}
55
56llvm::Error decodeError(const llvm::json::Object &O) {
57 llvm::StringRef Msg = O.getString(K: "message").value_or(u: "Unspecified error");
58 if (auto Code = O.getInteger(K: "code"))
59 return llvm::make_error<LSPError>(Args: Msg.str(), Args: ErrorCode(*Code));
60 return error(Msg: Msg.str());
61}
62
63class JSONTransport : public Transport {
64public:
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(Message: llvm::json::Object{
72 {.K: "jsonrpc", .V: "2.0"},
73 {.K: "method", .V: Method},
74 {.K: "params", .V: std::move(Params)},
75 });
76 }
77 void call(llvm::StringRef Method, llvm::json::Value Params,
78 llvm::json::Value ID) override {
79 sendMessage(Message: llvm::json::Object{
80 {.K: "jsonrpc", .V: "2.0"},
81 {.K: "id", .V: std::move(ID)},
82 {.K: "method", .V: Method},
83 {.K: "params", .V: 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(Message: llvm::json::Object{
90 {.K: "jsonrpc", .V: "2.0"},
91 {.K: "id", .V: std::move(ID)},
92 {.K: "result", .V: std::move(*Result)},
93 });
94 } else {
95 sendMessage(Message: llvm::json::Object{
96 {.K: "jsonrpc", .V: "2.0"},
97 {.K: "id", .V: std::move(ID)},
98 {.K: "error", .V: encodeError(E: 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(stream: In)) {
106 if (shutdownRequested())
107 return error(EC: std::make_error_code(e: std::errc::operation_canceled),
108 Fmt: "Got signal, shutting down");
109 if (ferror(stream: In))
110 return llvm::errorCodeToError(
111 EC: 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(Fmt: Pretty ? "<<< {0:2}\n" : "<<< {0}\n", Vals&: *Doc);
120 if (!handleMessage(Message: 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(Fmt: "<<< {0}\n", Vals&: JSON);
125 elog(Fmt: "JSON parse error: {0}", Vals: llvm::toString(E: Doc.takeError()));
126 }
127 }
128 }
129 return llvm::errorCodeToError(EC: std::make_error_code(e: std::errc::io_error));
130 }
131
132private:
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(Fmt: Pretty ? "{0:2}" : "{0}", Vals&: Message);
140 Out << "Content-Length: " << OutputBuffer.size() << "\r\n\r\n"
141 << OutputBuffer;
142 Out.flush();
143 vlog(Fmt: ">>> {0}\n", Vals&: 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
162bool 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(K: "jsonrpc") != std::optional<llvm::StringRef>("2.0")) {
168 elog(Fmt: "Not a JSON-RPC 2.0 message: {0:2}", Vals&: 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(K: "id"))
174 ID = std::move(*I);
175 auto Method = Object->getString(K: "method");
176 if (!Method) { // This is a response.
177 if (!ID) {
178 elog(Fmt: "No method and no response ID: {0:2}", Vals&: Message);
179 return false;
180 }
181 if (auto *Err = Object->getObject(K: "error"))
182 return Handler.onReply(ID: std::move(*ID), Result: decodeError(O: *Err));
183 // Result should be given, use null if not.
184 llvm::json::Value Result = nullptr;
185 if (auto *R = Object->get(K: "result"))
186 Result = std::move(*R);
187 return Handler.onReply(ID: std::move(*ID), Result: 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(K: "params"))
192 Params = std::move(*P);
193
194 if (ID)
195 return Handler.onCall(Method: *Method, Params: std::move(Params), ID: std::move(*ID));
196 return Handler.onNotify(Method: *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.
201bool 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(N: Size + BufSize);
209 // Handle EINTR which is sent when a debugger attaches on some platforms.
210 if (!retryAfterSignalUnlessShutdown(
211 Fail: nullptr, F: [&] { return std::fgets(s: &Out[Size], n: BufSize, stream: In); }))
212 return false;
213 clearerr(stream: 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(s: &Out[Size]);
217 if (Read > 0 && Out[Size + Read - 1] == '\n') {
218 Out.resize(N: 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)
228bool 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(stream: In) || ferror(stream: In) || !readLine(In, Out&: 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.starts_with(Prefix: "#"))
244 continue;
245
246 // Content-Length is a mandatory header, and the only one we handle.
247 if (LineRef.consume_front(Prefix: "Content-Length: ")) {
248 if (ContentLength != 0) {
249 elog(Fmt: "Warning: Duplicate Content-Length header received. "
250 "The previous value for this message ({0}) was ignored.",
251 Vals&: ContentLength);
252 }
253 llvm::getAsUnsignedInteger(Str: LineRef.trim(), Radix: 0, Result&: 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(Fmt: "Refusing to read message with long Content-Length: {0}. "
268 "Expect protocol errors",
269 Vals&: ContentLength);
270 return false;
271 }
272 if (ContentLength == 0) {
273 log(Fmt: "Warning: Missing Content-Length header, or zero-length message.");
274 return false;
275 }
276
277 JSON.resize(n: 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(Fail: 0, F: [&]{
281 return std::fread(ptr: &JSON[Pos], size: 1, n: ContentLength - Pos, stream: In);
282 });
283 if (Read == 0) {
284 elog(Fmt: "Input was aborted. Read only {0} bytes of expected {1}.", Vals&: Pos,
285 Vals&: ContentLength);
286 return false;
287 }
288 InMirror << llvm::StringRef(&JSON[Pos], Read);
289 clearerr(stream: 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.
301bool JSONTransport::readDelimitedMessage(std::string &JSON) {
302 JSON.clear();
303 llvm::SmallString<128> Line;
304 while (readLine(In, Out&: Line)) {
305 InMirror << Line;
306 auto LineRef = Line.str().trim();
307 if (LineRef.starts_with(Prefix: "#")) // 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(stream: In)) {
320 elog(Fmt: "Input error while reading message!");
321 return false;
322 }
323 return true; // Including at EOF
324}
325
326} // namespace
327
328std::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>(args&: In, args&: Out, args&: InMirror, args&: Pretty, args&: Style);
334}
335
336} // namespace clangd
337} // namespace clang
338

source code of clang-tools-extra/clangd/JSONTransport.cpp