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