1//===-- IOHandler.cpp -----------------------------------------------------===//
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
9#include "lldb/Core/IOHandler.h"
10
11#if defined(__APPLE__)
12#include <deque>
13#endif
14#include <string>
15
16#include "lldb/Core/Debugger.h"
17#include "lldb/Core/StreamFile.h"
18#include "lldb/Host/Config.h"
19#include "lldb/Host/File.h"
20#include "lldb/Utility/Predicate.h"
21#include "lldb/Utility/ReproducerProvider.h"
22#include "lldb/Utility/Status.h"
23#include "lldb/Utility/StreamString.h"
24#include "lldb/Utility/StringList.h"
25#include "lldb/lldb-forward.h"
26
27#if LLDB_ENABLE_LIBEDIT
28#include "lldb/Host/Editline.h"
29#endif
30#include "lldb/Interpreter/CommandCompletions.h"
31#include "lldb/Interpreter/CommandInterpreter.h"
32#include "llvm/ADT/StringRef.h"
33
34#ifdef _WIN32
35#include "lldb/Host/windows/windows.h"
36#endif
37
38#include <memory>
39#include <mutex>
40
41#include <assert.h>
42#include <ctype.h>
43#include <errno.h>
44#include <locale.h>
45#include <stdint.h>
46#include <stdio.h>
47#include <string.h>
48#include <type_traits>
49
50using namespace lldb;
51using namespace lldb_private;
52using llvm::None;
53using llvm::Optional;
54using llvm::StringRef;
55
56IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type)
57 : IOHandler(debugger, type,
58 FileSP(), // Adopt STDIN from top input reader
59 StreamFileSP(), // Adopt STDOUT from top input reader
60 StreamFileSP(), // Adopt STDERR from top input reader
61 0, // Flags
62 nullptr // Shadow file recorder
63 ) {}
64
65IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type,
66 const lldb::FileSP &input_sp,
67 const lldb::StreamFileSP &output_sp,
68 const lldb::StreamFileSP &error_sp, uint32_t flags,
69 repro::DataRecorder *data_recorder)
70 : m_debugger(debugger), m_input_sp(input_sp), m_output_sp(output_sp),
71 m_error_sp(error_sp), m_data_recorder(data_recorder), m_popped(false),
72 m_flags(flags), m_type(type), m_user_data(nullptr), m_done(false),
73 m_active(false) {
74 // If any files are not specified, then adopt them from the top input reader.
75 if (!m_input_sp || !m_output_sp || !m_error_sp)
76 debugger.AdoptTopIOHandlerFilesIfInvalid(m_input_sp, m_output_sp,
77 m_error_sp);
78}
79
80IOHandler::~IOHandler() = default;
81
82int IOHandler::GetInputFD() {
83 return (m_input_sp ? m_input_sp->GetDescriptor() : -1);
84}
85
86int IOHandler::GetOutputFD() {
87 return (m_output_sp ? m_output_sp->GetFile().GetDescriptor() : -1);
88}
89
90int IOHandler::GetErrorFD() {
91 return (m_error_sp ? m_error_sp->GetFile().GetDescriptor() : -1);
92}
93
94FILE *IOHandler::GetInputFILE() {
95 return (m_input_sp ? m_input_sp->GetStream() : nullptr);
96}
97
98FILE *IOHandler::GetOutputFILE() {
99 return (m_output_sp ? m_output_sp->GetFile().GetStream() : nullptr);
100}
101
102FILE *IOHandler::GetErrorFILE() {
103 return (m_error_sp ? m_error_sp->GetFile().GetStream() : nullptr);
104}
105
106FileSP IOHandler::GetInputFileSP() { return m_input_sp; }
107
108StreamFileSP IOHandler::GetOutputStreamFileSP() { return m_output_sp; }
109
110StreamFileSP IOHandler::GetErrorStreamFileSP() { return m_error_sp; }
111
112bool IOHandler::GetIsInteractive() {
113 return GetInputFileSP() ? GetInputFileSP()->GetIsInteractive() : false;
114}
115
116bool IOHandler::GetIsRealTerminal() {
117 return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false;
118}
119
120void IOHandler::SetPopped(bool b) { m_popped.SetValue(b, eBroadcastOnChange); }
121
122void IOHandler::WaitForPop() { m_popped.WaitForValueEqualTo(true); }
123
124void IOHandlerStack::PrintAsync(Stream *stream, const char *s, size_t len) {
125 if (stream) {
126 std::lock_guard<std::recursive_mutex> guard(m_mutex);
127 if (m_top)
128 m_top->PrintAsync(stream, s, len);
129 else
130 stream->Write(s, len);
131 }
132}
133
134IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
135 bool default_response)
136 : IOHandlerEditline(
137 debugger, IOHandler::Type::Confirm,
138 nullptr, // nullptr editline_name means no history loaded/saved
139 llvm::StringRef(), // No prompt
140 llvm::StringRef(), // No continuation prompt
141 false, // Multi-line
142 false, // Don't colorize the prompt (i.e. the confirm message.)
143 0, *this, nullptr),
144 m_default_response(default_response), m_user_response(default_response) {
145 StreamString prompt_stream;
146 prompt_stream.PutCString(prompt);
147 if (m_default_response)
148 prompt_stream.Printf(": [Y/n] ");
149 else
150 prompt_stream.Printf(": [y/N] ");
151
152 SetPrompt(prompt_stream.GetString());
153}
154
155IOHandlerConfirm::~IOHandlerConfirm() = default;
156
157void IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler,
158 CompletionRequest &request) {
159 if (request.GetRawCursorPos() != 0)
160 return;
161 request.AddCompletion(m_default_response ? "y" : "n");
162}
163
164void IOHandlerConfirm::IOHandlerInputComplete(IOHandler &io_handler,
165 std::string &line) {
166 if (line.empty()) {
167 // User just hit enter, set the response to the default
168 m_user_response = m_default_response;
169 io_handler.SetIsDone(true);
170 return;
171 }
172
173 if (line.size() == 1) {
174 switch (line[0]) {
175 case 'y':
176 case 'Y':
177 m_user_response = true;
178 io_handler.SetIsDone(true);
179 return;
180 case 'n':
181 case 'N':
182 m_user_response = false;
183 io_handler.SetIsDone(true);
184 return;
185 default:
186 break;
187 }
188 }
189
190 if (line == "yes" || line == "YES" || line == "Yes") {
191 m_user_response = true;
192 io_handler.SetIsDone(true);
193 } else if (line == "no" || line == "NO" || line == "No") {
194 m_user_response = false;
195 io_handler.SetIsDone(true);
196 }
197}
198
199llvm::Optional<std::string>
200IOHandlerDelegate::IOHandlerSuggestion(IOHandler &io_handler,
201 llvm::StringRef line) {
202 return io_handler.GetDebugger()
203 .GetCommandInterpreter()
204 .GetAutoSuggestionForCommand(line);
205}
206
207void IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
208 CompletionRequest &request) {
209 switch (m_completion) {
210 case Completion::None:
211 break;
212 case Completion::LLDBCommand:
213 io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(request);
214 break;
215 case Completion::Expression:
216 CommandCompletions::InvokeCommonCompletionCallbacks(
217 io_handler.GetDebugger().GetCommandInterpreter(),
218 CommandCompletions::eVariablePathCompletion, request, nullptr);
219 break;
220 }
221}
222
223IOHandlerEditline::IOHandlerEditline(
224 Debugger &debugger, IOHandler::Type type,
225 const char *editline_name, // Used for saving history files
226 llvm::StringRef prompt, llvm::StringRef continuation_prompt,
227 bool multi_line, bool color_prompts, uint32_t line_number_start,
228 IOHandlerDelegate &delegate, repro::DataRecorder *data_recorder)
229 : IOHandlerEditline(debugger, type,
230 FileSP(), // Inherit input from top input reader
231 StreamFileSP(), // Inherit output from top input reader
232 StreamFileSP(), // Inherit error from top input reader
233 0, // Flags
234 editline_name, // Used for saving history files
235 prompt, continuation_prompt, multi_line, color_prompts,
236 line_number_start, delegate, data_recorder) {}
237
238IOHandlerEditline::IOHandlerEditline(
239 Debugger &debugger, IOHandler::Type type, const lldb::FileSP &input_sp,
240 const lldb::StreamFileSP &output_sp, const lldb::StreamFileSP &error_sp,
241 uint32_t flags,
242 const char *editline_name, // Used for saving history files
243 llvm::StringRef prompt, llvm::StringRef continuation_prompt,
244 bool multi_line, bool color_prompts, uint32_t line_number_start,
245 IOHandlerDelegate &delegate, repro::DataRecorder *data_recorder)
246 : IOHandler(debugger, type, input_sp, output_sp, error_sp, flags,
247 data_recorder),
248#if LLDB_ENABLE_LIBEDIT
249 m_editline_up(),
250#endif
251 m_delegate(delegate), m_prompt(), m_continuation_prompt(),
252 m_current_lines_ptr(nullptr), m_base_line_number(line_number_start),
253 m_curr_line_idx(UINT32_MAX), m_multi_line(multi_line),
254 m_color_prompts(color_prompts), m_interrupt_exits(true),
255 m_editing(false) {
256 SetPrompt(prompt);
257
258#if LLDB_ENABLE_LIBEDIT
259 bool use_editline = false;
260
261 use_editline = GetInputFILE() && GetOutputFILE() && GetErrorFILE() &&
262 m_input_sp && m_input_sp->GetIsRealTerminal();
263
264 if (use_editline) {
265 m_editline_up = std::make_unique<Editline>(editline_name, GetInputFILE(),
266 GetOutputFILE(), GetErrorFILE(),
267 m_color_prompts);
268 m_editline_up->SetIsInputCompleteCallback(
269 [this](Editline *editline, StringList &lines) {
270 return this->IsInputCompleteCallback(editline, lines);
271 });
272
273 m_editline_up->SetAutoCompleteCallback([this](CompletionRequest &request) {
274 this->AutoCompleteCallback(request);
275 });
276
277 if (debugger.GetUseAutosuggestion() && debugger.GetUseColor()) {
278 m_editline_up->SetSuggestionCallback([this](llvm::StringRef line) {
279 return this->SuggestionCallback(line);
280 });
281 }
282 // See if the delegate supports fixing indentation
283 const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
284 if (indent_chars) {
285 // The delegate does support indentation, hook it up so when any
286 // indentation character is typed, the delegate gets a chance to fix it
287 FixIndentationCallbackType f = [this](Editline *editline,
288 const StringList &lines,
289 int cursor_position) {
290 return this->FixIndentationCallback(editline, lines, cursor_position);
291 };
292 m_editline_up->SetFixIndentationCallback(std::move(f), indent_chars);
293 }
294 }
295#endif
296 SetBaseLineNumber(m_base_line_number);
297 SetPrompt(prompt);
298 SetContinuationPrompt(continuation_prompt);
299}
300
301IOHandlerEditline::~IOHandlerEditline() {
302#if LLDB_ENABLE_LIBEDIT
303 m_editline_up.reset();
304#endif
305}
306
307void IOHandlerEditline::Activate() {
308 IOHandler::Activate();
309 m_delegate.IOHandlerActivated(*this, GetIsInteractive());
310}
311
312void IOHandlerEditline::Deactivate() {
313 IOHandler::Deactivate();
314 m_delegate.IOHandlerDeactivated(*this);
315}
316
317void IOHandlerEditline::TerminalSizeChanged() {
318#if LLDB_ENABLE_LIBEDIT
319 if (m_editline_up)
320 m_editline_up->TerminalSizeChanged();
321#endif
322}
323
324// Split out a line from the buffer, if there is a full one to get.
325static Optional<std::string> SplitLine(std::string &line_buffer) {
326 size_t pos = line_buffer.find('\n');
327 if (pos == std::string::npos)
328 return None;
329 std::string line =
330 std::string(StringRef(line_buffer.c_str(), pos).rtrim("\n\r"));
331 line_buffer = line_buffer.substr(pos + 1);
332 return line;
333}
334
335// If the final line of the file ends without a end-of-line, return
336// it as a line anyway.
337static Optional<std::string> SplitLineEOF(std::string &line_buffer) {
338 if (llvm::all_of(line_buffer, llvm::isSpace))
339 return None;
340 std::string line = std::move(line_buffer);
341 line_buffer.clear();
342 return line;
343}
344
345bool IOHandlerEditline::GetLine(std::string &line, bool &interrupted) {
346#if LLDB_ENABLE_LIBEDIT
347 if (m_editline_up) {
348 bool b = m_editline_up->GetLine(line, interrupted);
349 if (b && m_data_recorder)
350 m_data_recorder->Record(line, true);
351 return b;
352 }
353#endif
354
355 line.clear();
356
357 if (GetIsInteractive()) {
358 const char *prompt = nullptr;
359
360 if (m_multi_line && m_curr_line_idx > 0)
361 prompt = GetContinuationPrompt();
362
363 if (prompt == nullptr)
364 prompt = GetPrompt();
365
366 if (prompt && prompt[0]) {
367 if (m_output_sp) {
368 m_output_sp->Printf("%s", prompt);
369 m_output_sp->Flush();
370 }
371 }
372 }
373
374 Optional<std::string> got_line = SplitLine(m_line_buffer);
375
376 if (!got_line && !m_input_sp) {
377 // No more input file, we are done...
378 SetIsDone(true);
379 return false;
380 }
381
382 FILE *in = GetInputFILE();
383 char buffer[256];
384
385 if (!got_line && !in && m_input_sp) {
386 // there is no FILE*, fall back on just reading bytes from the stream.
387 while (!got_line) {
388 size_t bytes_read = sizeof(buffer);
389 Status error = m_input_sp->Read((void *)buffer, bytes_read);
390 if (error.Success() && !bytes_read) {
391 got_line = SplitLineEOF(m_line_buffer);
392 break;
393 }
394 if (error.Fail())
395 break;
396 m_line_buffer += StringRef(buffer, bytes_read);
397 got_line = SplitLine(m_line_buffer);
398 }
399 }
400
401 if (!got_line && in) {
402 m_editing = true;
403 while (!got_line) {
404 char *r = fgets(buffer, sizeof(buffer), in);
405#ifdef _WIN32
406 // ReadFile on Windows is supposed to set ERROR_OPERATION_ABORTED
407 // according to the docs on MSDN. However, this has evidently been a
408 // known bug since Windows 8. Therefore, we can't detect if a signal
409 // interrupted in the fgets. So pressing ctrl-c causes the repl to end
410 // and the process to exit. A temporary workaround is just to attempt to
411 // fgets twice until this bug is fixed.
412 if (r == nullptr)
413 r = fgets(buffer, sizeof(buffer), in);
414 // this is the equivalent of EINTR for Windows
415 if (r == nullptr && GetLastError() == ERROR_OPERATION_ABORTED)
416 continue;
417#endif
418 if (r == nullptr) {
419 if (ferror(in) && errno == EINTR)
420 continue;
421 if (feof(in))
422 got_line = SplitLineEOF(m_line_buffer);
423 break;
424 }
425 m_line_buffer += buffer;
426 got_line = SplitLine(m_line_buffer);
427 }
428 m_editing = false;
429 }
430
431 if (got_line) {
432 line = got_line.getValue();
433 if (m_data_recorder)
434 m_data_recorder->Record(line, true);
435 }
436
437 return (bool)got_line;
438}
439
440#if LLDB_ENABLE_LIBEDIT
441bool IOHandlerEditline::IsInputCompleteCallback(Editline *editline,
442 StringList &lines) {
443 return m_delegate.IOHandlerIsInputComplete(*this, lines);
444}
445
446int IOHandlerEditline::FixIndentationCallback(Editline *editline,
447 const StringList &lines,
448 int cursor_position) {
449 return m_delegate.IOHandlerFixIndentation(*this, lines, cursor_position);
450}
451
452llvm::Optional<std::string>
453IOHandlerEditline::SuggestionCallback(llvm::StringRef line) {
454 return m_delegate.IOHandlerSuggestion(*this, line);
455}
456
457void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request) {
458 m_delegate.IOHandlerComplete(*this, request);
459}
460#endif
461
462const char *IOHandlerEditline::GetPrompt() {
463#if LLDB_ENABLE_LIBEDIT
464 if (m_editline_up) {
465 return m_editline_up->GetPrompt();
466 } else {
467#endif
468 if (m_prompt.empty())
469 return nullptr;
470#if LLDB_ENABLE_LIBEDIT
471 }
472#endif
473 return m_prompt.c_str();
474}
475
476bool IOHandlerEditline::SetPrompt(llvm::StringRef prompt) {
477 m_prompt = std::string(prompt);
478
479#if LLDB_ENABLE_LIBEDIT
480 if (m_editline_up)
481 m_editline_up->SetPrompt(m_prompt.empty() ? nullptr : m_prompt.c_str());
482#endif
483 return true;
484}
485
486const char *IOHandlerEditline::GetContinuationPrompt() {
487 return (m_continuation_prompt.empty() ? nullptr
488 : m_continuation_prompt.c_str());
489}
490
491void IOHandlerEditline::SetContinuationPrompt(llvm::StringRef prompt) {
492 m_continuation_prompt = std::string(prompt);
493
494#if LLDB_ENABLE_LIBEDIT
495 if (m_editline_up)
496 m_editline_up->SetContinuationPrompt(m_continuation_prompt.empty()
497 ? nullptr
498 : m_continuation_prompt.c_str());
499#endif
500}
501
502void IOHandlerEditline::SetBaseLineNumber(uint32_t line) {
503 m_base_line_number = line;
504}
505
506uint32_t IOHandlerEditline::GetCurrentLineIndex() const {
507#if LLDB_ENABLE_LIBEDIT
508 if (m_editline_up)
509 return m_editline_up->GetCurrentLine();
510#endif
511 return m_curr_line_idx;
512}
513
514bool IOHandlerEditline::GetLines(StringList &lines, bool &interrupted) {
515 m_current_lines_ptr = &lines;
516
517 bool success = false;
518#if LLDB_ENABLE_LIBEDIT
519 if (m_editline_up) {
520 return m_editline_up->GetLines(m_base_line_number, lines, interrupted);
521 } else {
522#endif
523 bool done = false;
524 Status error;
525
526 while (!done) {
527 // Show line numbers if we are asked to
528 std::string line;
529 if (m_base_line_number > 0 && GetIsInteractive()) {
530 if (m_output_sp) {
531 m_output_sp->Printf("%u%s",
532 m_base_line_number + (uint32_t)lines.GetSize(),
533 GetPrompt() == nullptr ? " " : "");
534 }
535 }
536
537 m_curr_line_idx = lines.GetSize();
538
539 bool interrupted = false;
540 if (GetLine(line, interrupted) && !interrupted) {
541 lines.AppendString(line);
542 done = m_delegate.IOHandlerIsInputComplete(*this, lines);
543 } else {
544 done = true;
545 }
546 }
547 success = lines.GetSize() > 0;
548#if LLDB_ENABLE_LIBEDIT
549 }
550#endif
551 return success;
552}
553
554// Each IOHandler gets to run until it is done. It should read data from the
555// "in" and place output into "out" and "err and return when done.
556void IOHandlerEditline::Run() {
557 std::string line;
558 while (IsActive()) {
559 bool interrupted = false;
560 if (m_multi_line) {
561 StringList lines;
562 if (GetLines(lines, interrupted)) {
563 if (interrupted) {
564 m_done = m_interrupt_exits;
565 m_delegate.IOHandlerInputInterrupted(*this, line);
566
567 } else {
568 line = lines.CopyList();
569 m_delegate.IOHandlerInputComplete(*this, line);
570 }
571 } else {
572 m_done = true;
573 }
574 } else {
575 if (GetLine(line, interrupted)) {
576 if (interrupted)
577 m_delegate.IOHandlerInputInterrupted(*this, line);
578 else
579 m_delegate.IOHandlerInputComplete(*this, line);
580 } else {
581 m_done = true;
582 }
583 }
584 }
585}
586
587void IOHandlerEditline::Cancel() {
588#if LLDB_ENABLE_LIBEDIT
589 if (m_editline_up)
590 m_editline_up->Cancel();
591#endif
592}
593
594bool IOHandlerEditline::Interrupt() {
595 // Let the delgate handle it first
596 if (m_delegate.IOHandlerInterrupt(*this))
597 return true;
598
599#if LLDB_ENABLE_LIBEDIT
600 if (m_editline_up)
601 return m_editline_up->Interrupt();
602#endif
603 return false;
604}
605
606void IOHandlerEditline::GotEOF() {
607#if LLDB_ENABLE_LIBEDIT
608 if (m_editline_up)
609 m_editline_up->Interrupt();
610#endif
611}
612
613void IOHandlerEditline::PrintAsync(Stream *stream, const char *s, size_t len) {
614#if LLDB_ENABLE_LIBEDIT
615 if (m_editline_up)
616 m_editline_up->PrintAsync(stream, s, len);
617 else
618#endif
619 {
620#ifdef _WIN32
621 const char *prompt = GetPrompt();
622 if (prompt) {
623 // Back up over previous prompt using Windows API
624 CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
625 HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
626 GetConsoleScreenBufferInfo(console_handle, &screen_buffer_info);
627 COORD coord = screen_buffer_info.dwCursorPosition;
628 coord.X -= strlen(prompt);
629 if (coord.X < 0)
630 coord.X = 0;
631 SetConsoleCursorPosition(console_handle, coord);
632 }
633#endif
634 IOHandler::PrintAsync(stream, s, len);
635#ifdef _WIN32
636 if (prompt)
637 IOHandler::PrintAsync(GetOutputStreamFileSP().get(), prompt,
638 strlen(prompt));
639#endif
640 }
641}
642