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