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 | 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 | |
56 | llvm::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 | |
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(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 | |
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(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 | |
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(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. |
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(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) |
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(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. |
301 | bool 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 | |
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>(args&: In, args&: Out, args&: InMirror, args&: Pretty, args&: Style); |
334 | } |
335 | |
336 | } // namespace clangd |
337 | } // namespace clang |
338 | |