clang-tools 10.0.0

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