ConnectionFileDescriptorPosix.cpp revision 341825
1//===-- ConnectionFileDescriptorPosix.cpp -----------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#if defined(__APPLE__) 11// Enable this special support for Apple builds where we can have unlimited 12// select bounds. We tried switching to poll() and kqueue and we were panicing 13// the kernel, so we have to stick with select for now. 14#define _DARWIN_UNLIMITED_SELECT 15#endif 16 17#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h" 18#include "lldb/Host/Config.h" 19#include "lldb/Host/Socket.h" 20#include "lldb/Host/SocketAddress.h" 21#include "lldb/Utility/SelectHelper.h" 22#include "lldb/Utility/Timeout.h" 23 24// C Includes 25#include <errno.h> 26#include <fcntl.h> 27#include <stdlib.h> 28#include <string.h> 29#include <sys/types.h> 30 31#ifndef LLDB_DISABLE_POSIX 32#include <termios.h> 33#include <unistd.h> 34#endif 35 36// C++ Includes 37#include <sstream> 38 39// Other libraries and framework includes 40#include "llvm/Support/Errno.h" 41#include "llvm/Support/ErrorHandling.h" 42#if defined(__APPLE__) 43#include "llvm/ADT/SmallVector.h" 44#endif 45// Project includes 46#include "lldb/Host/Host.h" 47#include "lldb/Host/Socket.h" 48#include "lldb/Host/common/TCPSocket.h" 49#include "lldb/Utility/Log.h" 50#include "lldb/Utility/StreamString.h" 51#include "lldb/Utility/Timer.h" 52 53using namespace lldb; 54using namespace lldb_private; 55 56const char *ConnectionFileDescriptor::LISTEN_SCHEME = "listen"; 57const char *ConnectionFileDescriptor::ACCEPT_SCHEME = "accept"; 58const char *ConnectionFileDescriptor::UNIX_ACCEPT_SCHEME = "unix-accept"; 59const char *ConnectionFileDescriptor::CONNECT_SCHEME = "connect"; 60const char *ConnectionFileDescriptor::TCP_CONNECT_SCHEME = "tcp-connect"; 61const char *ConnectionFileDescriptor::UDP_SCHEME = "udp"; 62const char *ConnectionFileDescriptor::UNIX_CONNECT_SCHEME = "unix-connect"; 63const char *ConnectionFileDescriptor::UNIX_ABSTRACT_CONNECT_SCHEME = 64 "unix-abstract-connect"; 65const char *ConnectionFileDescriptor::FD_SCHEME = "fd"; 66const char *ConnectionFileDescriptor::FILE_SCHEME = "file"; 67 68namespace { 69 70llvm::Optional<llvm::StringRef> GetURLAddress(llvm::StringRef url, 71 llvm::StringRef scheme) { 72 if (!url.consume_front(scheme)) 73 return llvm::None; 74 if (!url.consume_front("://")) 75 return llvm::None; 76 return url; 77} 78} 79 80ConnectionFileDescriptor::ConnectionFileDescriptor(bool child_processes_inherit) 81 : Connection(), m_pipe(), m_mutex(), m_shutting_down(false), 82 m_waiting_for_accept(false), 83 m_child_processes_inherit(child_processes_inherit) { 84 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION | 85 LIBLLDB_LOG_OBJECT)); 86 if (log) 87 log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor ()", 88 static_cast<void *>(this)); 89} 90 91ConnectionFileDescriptor::ConnectionFileDescriptor(int fd, bool owns_fd) 92 : Connection(), m_pipe(), m_mutex(), m_shutting_down(false), 93 m_waiting_for_accept(false), m_child_processes_inherit(false) { 94 m_write_sp.reset(new File(fd, owns_fd)); 95 m_read_sp.reset(new File(fd, false)); 96 97 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION | 98 LIBLLDB_LOG_OBJECT)); 99 if (log) 100 log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = " 101 "%i, owns_fd = %i)", 102 static_cast<void *>(this), fd, owns_fd); 103 OpenCommandPipe(); 104} 105 106ConnectionFileDescriptor::ConnectionFileDescriptor(Socket *socket) 107 : Connection(), m_pipe(), m_mutex(), m_shutting_down(false), 108 m_waiting_for_accept(false), m_child_processes_inherit(false) { 109 InitializeSocket(socket); 110} 111 112ConnectionFileDescriptor::~ConnectionFileDescriptor() { 113 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION | 114 LIBLLDB_LOG_OBJECT)); 115 if (log) 116 log->Printf("%p ConnectionFileDescriptor::~ConnectionFileDescriptor ()", 117 static_cast<void *>(this)); 118 Disconnect(NULL); 119 CloseCommandPipe(); 120} 121 122void ConnectionFileDescriptor::OpenCommandPipe() { 123 CloseCommandPipe(); 124 125 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 126 // Make the command file descriptor here: 127 Status result = m_pipe.CreateNew(m_child_processes_inherit); 128 if (!result.Success()) { 129 if (log) 130 log->Printf("%p ConnectionFileDescriptor::OpenCommandPipe () - could not " 131 "make pipe: %s", 132 static_cast<void *>(this), result.AsCString()); 133 } else { 134 if (log) 135 log->Printf("%p ConnectionFileDescriptor::OpenCommandPipe() - success " 136 "readfd=%d writefd=%d", 137 static_cast<void *>(this), m_pipe.GetReadFileDescriptor(), 138 m_pipe.GetWriteFileDescriptor()); 139 } 140} 141 142void ConnectionFileDescriptor::CloseCommandPipe() { 143 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 144 if (log) 145 log->Printf("%p ConnectionFileDescriptor::CloseCommandPipe()", 146 static_cast<void *>(this)); 147 148 m_pipe.Close(); 149} 150 151bool ConnectionFileDescriptor::IsConnected() const { 152 return (m_read_sp && m_read_sp->IsValid()) || 153 (m_write_sp && m_write_sp->IsValid()); 154} 155 156ConnectionStatus ConnectionFileDescriptor::Connect(llvm::StringRef path, 157 Status *error_ptr) { 158 std::lock_guard<std::recursive_mutex> guard(m_mutex); 159 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 160 if (log) 161 log->Printf("%p ConnectionFileDescriptor::Connect (url = '%s')", 162 static_cast<void *>(this), path.str().c_str()); 163 164 OpenCommandPipe(); 165 166 if (!path.empty()) { 167 llvm::Optional<llvm::StringRef> addr; 168 if ((addr = GetURLAddress(path, LISTEN_SCHEME))) { 169 // listen://HOST:PORT 170 return SocketListenAndAccept(*addr, error_ptr); 171 } else if ((addr = GetURLAddress(path, ACCEPT_SCHEME))) { 172 // unix://SOCKNAME 173 return NamedSocketAccept(*addr, error_ptr); 174 } else if ((addr = GetURLAddress(path, UNIX_ACCEPT_SCHEME))) { 175 // unix://SOCKNAME 176 return NamedSocketAccept(*addr, error_ptr); 177 } else if ((addr = GetURLAddress(path, CONNECT_SCHEME))) { 178 return ConnectTCP(*addr, error_ptr); 179 } else if ((addr = GetURLAddress(path, TCP_CONNECT_SCHEME))) { 180 return ConnectTCP(*addr, error_ptr); 181 } else if ((addr = GetURLAddress(path, UDP_SCHEME))) { 182 return ConnectUDP(*addr, error_ptr); 183 } else if ((addr = GetURLAddress(path, UNIX_CONNECT_SCHEME))) { 184 // unix-connect://SOCKNAME 185 return NamedSocketConnect(*addr, error_ptr); 186 } else if ((addr = GetURLAddress(path, UNIX_ABSTRACT_CONNECT_SCHEME))) { 187 // unix-abstract-connect://SOCKNAME 188 return UnixAbstractSocketConnect(*addr, error_ptr); 189 } 190#ifndef LLDB_DISABLE_POSIX 191 else if ((addr = GetURLAddress(path, FD_SCHEME))) { 192 // Just passing a native file descriptor within this current process that 193 // is already opened (possibly from a service or other source). 194 int fd = -1; 195 196 if (!addr->getAsInteger(0, fd)) { 197 // We have what looks to be a valid file descriptor, but we should make 198 // sure it is. We currently are doing this by trying to get the flags 199 // from the file descriptor and making sure it isn't a bad fd. 200 errno = 0; 201 int flags = ::fcntl(fd, F_GETFL, 0); 202 if (flags == -1 || errno == EBADF) { 203 if (error_ptr) 204 error_ptr->SetErrorStringWithFormat("stale file descriptor: %s", 205 path.str().c_str()); 206 m_read_sp.reset(); 207 m_write_sp.reset(); 208 return eConnectionStatusError; 209 } else { 210 // Don't take ownership of a file descriptor that gets passed to us 211 // since someone else opened the file descriptor and handed it to us. 212 // TODO: Since are using a URL to open connection we should 213 // eventually parse options using the web standard where we have 214 // "fd://123?opt1=value;opt2=value" and we can have an option be 215 // "owns=1" or "owns=0" or something like this to allow us to specify 216 // this. For now, we assume we must assume we don't own it. 217 218 std::unique_ptr<TCPSocket> tcp_socket; 219 tcp_socket.reset(new TCPSocket(fd, false, false)); 220 // Try and get a socket option from this file descriptor to see if 221 // this is a socket and set m_is_socket accordingly. 222 int resuse; 223 bool is_socket = 224 !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse); 225 if (is_socket) { 226 m_read_sp = std::move(tcp_socket); 227 m_write_sp = m_read_sp; 228 } else { 229 m_read_sp.reset(new File(fd, false)); 230 m_write_sp.reset(new File(fd, false)); 231 } 232 m_uri = *addr; 233 return eConnectionStatusSuccess; 234 } 235 } 236 237 if (error_ptr) 238 error_ptr->SetErrorStringWithFormat("invalid file descriptor: \"%s\"", 239 path.str().c_str()); 240 m_read_sp.reset(); 241 m_write_sp.reset(); 242 return eConnectionStatusError; 243 } else if ((addr = GetURLAddress(path, FILE_SCHEME))) { 244 std::string addr_str = addr->str(); 245 // file:///PATH 246 int fd = llvm::sys::RetryAfterSignal(-1, ::open, addr_str.c_str(), O_RDWR); 247 if (fd == -1) { 248 if (error_ptr) 249 error_ptr->SetErrorToErrno(); 250 return eConnectionStatusError; 251 } 252 253 if (::isatty(fd)) { 254 // Set up serial terminal emulation 255 struct termios options; 256 ::tcgetattr(fd, &options); 257 258 // Set port speed to maximum 259 ::cfsetospeed(&options, B115200); 260 ::cfsetispeed(&options, B115200); 261 262 // Raw input, disable echo and signals 263 options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); 264 265 // Make sure only one character is needed to return from a read 266 options.c_cc[VMIN] = 1; 267 options.c_cc[VTIME] = 0; 268 269 ::tcsetattr(fd, TCSANOW, &options); 270 } 271 272 int flags = ::fcntl(fd, F_GETFL, 0); 273 if (flags >= 0) { 274 if ((flags & O_NONBLOCK) == 0) { 275 flags |= O_NONBLOCK; 276 ::fcntl(fd, F_SETFL, flags); 277 } 278 } 279 m_read_sp.reset(new File(fd, true)); 280 m_write_sp.reset(new File(fd, false)); 281 return eConnectionStatusSuccess; 282 } 283#endif 284 if (error_ptr) 285 error_ptr->SetErrorStringWithFormat("unsupported connection URL: '%s'", 286 path.str().c_str()); 287 return eConnectionStatusError; 288 } 289 if (error_ptr) 290 error_ptr->SetErrorString("invalid connect arguments"); 291 return eConnectionStatusError; 292} 293 294bool ConnectionFileDescriptor::InterruptRead() { 295 size_t bytes_written = 0; 296 Status result = m_pipe.Write("i", 1, bytes_written); 297 return result.Success(); 298} 299 300ConnectionStatus ConnectionFileDescriptor::Disconnect(Status *error_ptr) { 301 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 302 if (log) 303 log->Printf("%p ConnectionFileDescriptor::Disconnect ()", 304 static_cast<void *>(this)); 305 306 ConnectionStatus status = eConnectionStatusSuccess; 307 308 if (!IsConnected()) { 309 if (log) 310 log->Printf( 311 "%p ConnectionFileDescriptor::Disconnect(): Nothing to disconnect", 312 static_cast<void *>(this)); 313 return eConnectionStatusSuccess; 314 } 315 316 if (m_read_sp && m_read_sp->IsValid() && 317 m_read_sp->GetFdType() == IOObject::eFDTypeSocket) 318 static_cast<Socket &>(*m_read_sp).PreDisconnect(); 319 320 // Try to get the ConnectionFileDescriptor's mutex. If we fail, that is 321 // quite likely because somebody is doing a blocking read on our file 322 // descriptor. If that's the case, then send the "q" char to the command 323 // file channel so the read will wake up and the connection will then know to 324 // shut down. 325 326 m_shutting_down = true; 327 328 std::unique_lock<std::recursive_mutex> locker(m_mutex, std::defer_lock); 329 if (!locker.try_lock()) { 330 if (m_pipe.CanWrite()) { 331 size_t bytes_written = 0; 332 Status result = m_pipe.Write("q", 1, bytes_written); 333 if (log) 334 log->Printf("%p ConnectionFileDescriptor::Disconnect(): Couldn't get " 335 "the lock, sent 'q' to %d, error = '%s'.", 336 static_cast<void *>(this), m_pipe.GetWriteFileDescriptor(), 337 result.AsCString()); 338 } else if (log) { 339 log->Printf("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the " 340 "lock, but no command pipe is available.", 341 static_cast<void *>(this)); 342 } 343 locker.lock(); 344 } 345 346 Status error = m_read_sp->Close(); 347 Status error2 = m_write_sp->Close(); 348 if (error.Fail() || error2.Fail()) 349 status = eConnectionStatusError; 350 if (error_ptr) 351 *error_ptr = error.Fail() ? error : error2; 352 353 // Close any pipes we were using for async interrupts 354 m_pipe.Close(); 355 356 m_uri.clear(); 357 m_shutting_down = false; 358 return status; 359} 360 361size_t ConnectionFileDescriptor::Read(void *dst, size_t dst_len, 362 const Timeout<std::micro> &timeout, 363 ConnectionStatus &status, 364 Status *error_ptr) { 365 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 366 367 std::unique_lock<std::recursive_mutex> locker(m_mutex, std::defer_lock); 368 if (!locker.try_lock()) { 369 if (log) 370 log->Printf("%p ConnectionFileDescriptor::Read () failed to get the " 371 "connection lock.", 372 static_cast<void *>(this)); 373 if (error_ptr) 374 error_ptr->SetErrorString("failed to get the connection lock for read."); 375 376 status = eConnectionStatusTimedOut; 377 return 0; 378 } 379 380 if (m_shutting_down) { 381 status = eConnectionStatusError; 382 return 0; 383 } 384 385 status = BytesAvailable(timeout, error_ptr); 386 if (status != eConnectionStatusSuccess) 387 return 0; 388 389 Status error; 390 size_t bytes_read = dst_len; 391 error = m_read_sp->Read(dst, bytes_read); 392 393 if (log) { 394 log->Printf("%p ConnectionFileDescriptor::Read() fd = %" PRIu64 395 ", dst = %p, dst_len = %" PRIu64 ") => %" PRIu64 ", error = %s", 396 static_cast<void *>(this), 397 static_cast<uint64_t>(m_read_sp->GetWaitableHandle()), 398 static_cast<void *>(dst), static_cast<uint64_t>(dst_len), 399 static_cast<uint64_t>(bytes_read), error.AsCString()); 400 } 401 402 if (bytes_read == 0) { 403 error.Clear(); // End-of-file. Do not automatically close; pass along for 404 // the end-of-file handlers. 405 status = eConnectionStatusEndOfFile; 406 } 407 408 if (error_ptr) 409 *error_ptr = error; 410 411 if (error.Fail()) { 412 uint32_t error_value = error.GetError(); 413 switch (error_value) { 414 case EAGAIN: // The file was marked for non-blocking I/O, and no data were 415 // ready to be read. 416 if (m_read_sp->GetFdType() == IOObject::eFDTypeSocket) 417 status = eConnectionStatusTimedOut; 418 else 419 status = eConnectionStatusSuccess; 420 return 0; 421 422 case EFAULT: // Buf points outside the allocated address space. 423 case EINTR: // A read from a slow device was interrupted before any data 424 // arrived by the delivery of a signal. 425 case EINVAL: // The pointer associated with fildes was negative. 426 case EIO: // An I/O error occurred while reading from the file system. 427 // The process group is orphaned. 428 // The file is a regular file, nbyte is greater than 0, the 429 // starting position is before the end-of-file, and the 430 // starting position is greater than or equal to the offset 431 // maximum established for the open file descriptor 432 // associated with fildes. 433 case EISDIR: // An attempt is made to read a directory. 434 case ENOBUFS: // An attempt to allocate a memory buffer fails. 435 case ENOMEM: // Insufficient memory is available. 436 status = eConnectionStatusError; 437 break; // Break to close.... 438 439 case ENOENT: // no such file or directory 440 case EBADF: // fildes is not a valid file or socket descriptor open for 441 // reading. 442 case ENXIO: // An action is requested of a device that does not exist.. 443 // A requested action cannot be performed by the device. 444 case ECONNRESET: // The connection is closed by the peer during a read 445 // attempt on a socket. 446 case ENOTCONN: // A read is attempted on an unconnected socket. 447 status = eConnectionStatusLostConnection; 448 break; // Break to close.... 449 450 case ETIMEDOUT: // A transmission timeout occurs during a read attempt on a 451 // socket. 452 status = eConnectionStatusTimedOut; 453 return 0; 454 455 default: 456 LLDB_LOG(log, "this = {0}, unexpected error: {1}", this, 457 llvm::sys::StrError(error_value)); 458 status = eConnectionStatusError; 459 break; // Break to close.... 460 } 461 462 return 0; 463 } 464 return bytes_read; 465} 466 467size_t ConnectionFileDescriptor::Write(const void *src, size_t src_len, 468 ConnectionStatus &status, 469 Status *error_ptr) { 470 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION)); 471 if (log) 472 log->Printf( 473 "%p ConnectionFileDescriptor::Write (src = %p, src_len = %" PRIu64 ")", 474 static_cast<void *>(this), static_cast<const void *>(src), 475 static_cast<uint64_t>(src_len)); 476 477 if (!IsConnected()) { 478 if (error_ptr) 479 error_ptr->SetErrorString("not connected"); 480 status = eConnectionStatusNoConnection; 481 return 0; 482 } 483 484 Status error; 485 486 size_t bytes_sent = src_len; 487 error = m_write_sp->Write(src, bytes_sent); 488 489 if (log) { 490 log->Printf("%p ConnectionFileDescriptor::Write(fd = %" PRIu64 491 ", src = %p, src_len = %" PRIu64 ") => %" PRIu64 492 " (error = %s)", 493 static_cast<void *>(this), 494 static_cast<uint64_t>(m_write_sp->GetWaitableHandle()), 495 static_cast<const void *>(src), static_cast<uint64_t>(src_len), 496 static_cast<uint64_t>(bytes_sent), error.AsCString()); 497 } 498 499 if (error_ptr) 500 *error_ptr = error; 501 502 if (error.Fail()) { 503 switch (error.GetError()) { 504 case EAGAIN: 505 case EINTR: 506 status = eConnectionStatusSuccess; 507 return 0; 508 509 case ECONNRESET: // The connection is closed by the peer during a read 510 // attempt on a socket. 511 case ENOTCONN: // A read is attempted on an unconnected socket. 512 status = eConnectionStatusLostConnection; 513 break; // Break to close.... 514 515 default: 516 status = eConnectionStatusError; 517 break; // Break to close.... 518 } 519 520 return 0; 521 } 522 523 status = eConnectionStatusSuccess; 524 return bytes_sent; 525} 526 527std::string ConnectionFileDescriptor::GetURI() { return m_uri; } 528 529// This ConnectionFileDescriptor::BytesAvailable() uses select() via 530// SelectHelper 531// 532// PROS: 533// - select is consistent across most unix platforms 534// - The Apple specific version allows for unlimited fds in the fd_sets by 535// setting the _DARWIN_UNLIMITED_SELECT define prior to including the 536// required header files. 537// CONS: 538// - on non-Apple platforms, only supports file descriptors up to FD_SETSIZE. 539// This implementation will assert if it runs into that hard limit to let 540// users know that another ConnectionFileDescriptor::BytesAvailable() should 541// be used or a new version of ConnectionFileDescriptor::BytesAvailable() 542// should be written for the system that is running into the limitations. 543 544ConnectionStatus 545ConnectionFileDescriptor::BytesAvailable(const Timeout<std::micro> &timeout, 546 Status *error_ptr) { 547 // Don't need to take the mutex here separately since we are only called from 548 // Read. If we ever get used more generally we will need to lock here as 549 // well. 550 551 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_CONNECTION)); 552 LLDB_LOG(log, "this = {0}, timeout = {1}", this, timeout); 553 554 // Make a copy of the file descriptors to make sure we don't have another 555 // thread change these values out from under us and cause problems in the 556 // loop below where like in FS_SET() 557 const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle(); 558 const int pipe_fd = m_pipe.GetReadFileDescriptor(); 559 560 if (handle != IOObject::kInvalidHandleValue) { 561 SelectHelper select_helper; 562 if (timeout) 563 select_helper.SetTimeout(*timeout); 564 565 select_helper.FDSetRead(handle); 566#if defined(_MSC_VER) 567 // select() won't accept pipes on Windows. The entire Windows codepath 568 // needs to be converted over to using WaitForMultipleObjects and event 569 // HANDLEs, but for now at least this will allow ::select() to not return 570 // an error. 571 const bool have_pipe_fd = false; 572#else 573 const bool have_pipe_fd = pipe_fd >= 0; 574#endif 575 if (have_pipe_fd) 576 select_helper.FDSetRead(pipe_fd); 577 578 while (handle == m_read_sp->GetWaitableHandle()) { 579 580 Status error = select_helper.Select(); 581 582 if (error_ptr) 583 *error_ptr = error; 584 585 if (error.Fail()) { 586 switch (error.GetError()) { 587 case EBADF: // One of the descriptor sets specified an invalid 588 // descriptor. 589 return eConnectionStatusLostConnection; 590 591 case EINVAL: // The specified time limit is invalid. One of its 592 // components is negative or too large. 593 default: // Other unknown error 594 return eConnectionStatusError; 595 596 case ETIMEDOUT: 597 return eConnectionStatusTimedOut; 598 599 case EAGAIN: // The kernel was (perhaps temporarily) unable to 600 // allocate the requested number of file descriptors, or 601 // we have non-blocking IO 602 case EINTR: // A signal was delivered before the time limit 603 // expired and before any of the selected events occurred. 604 break; // Lets keep reading to until we timeout 605 } 606 } else { 607 if (select_helper.FDIsSetRead(handle)) 608 return eConnectionStatusSuccess; 609 610 if (select_helper.FDIsSetRead(pipe_fd)) { 611 // There is an interrupt or exit command in the command pipe Read the 612 // data from that pipe: 613 char c; 614 615 ssize_t bytes_read = llvm::sys::RetryAfterSignal(-1, ::read, pipe_fd, &c, 1); 616 assert(bytes_read == 1); 617 (void)bytes_read; 618 switch (c) { 619 case 'q': 620 if (log) 621 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() " 622 "got data: %c from the command channel.", 623 static_cast<void *>(this), c); 624 return eConnectionStatusEndOfFile; 625 case 'i': 626 // Interrupt the current read 627 return eConnectionStatusInterrupted; 628 } 629 } 630 } 631 } 632 } 633 634 if (error_ptr) 635 error_ptr->SetErrorString("not connected"); 636 return eConnectionStatusLostConnection; 637} 638 639ConnectionStatus 640ConnectionFileDescriptor::NamedSocketAccept(llvm::StringRef socket_name, 641 Status *error_ptr) { 642 Socket *socket = nullptr; 643 Status error = 644 Socket::UnixDomainAccept(socket_name, m_child_processes_inherit, socket); 645 if (error_ptr) 646 *error_ptr = error; 647 m_write_sp.reset(socket); 648 m_read_sp = m_write_sp; 649 if (error.Fail()) { 650 return eConnectionStatusError; 651 } 652 m_uri.assign(socket_name); 653 return eConnectionStatusSuccess; 654} 655 656ConnectionStatus 657ConnectionFileDescriptor::NamedSocketConnect(llvm::StringRef socket_name, 658 Status *error_ptr) { 659 Socket *socket = nullptr; 660 Status error = 661 Socket::UnixDomainConnect(socket_name, m_child_processes_inherit, socket); 662 if (error_ptr) 663 *error_ptr = error; 664 m_write_sp.reset(socket); 665 m_read_sp = m_write_sp; 666 if (error.Fail()) { 667 return eConnectionStatusError; 668 } 669 m_uri.assign(socket_name); 670 return eConnectionStatusSuccess; 671} 672 673lldb::ConnectionStatus 674ConnectionFileDescriptor::UnixAbstractSocketConnect(llvm::StringRef socket_name, 675 Status *error_ptr) { 676 Socket *socket = nullptr; 677 Status error = Socket::UnixAbstractConnect(socket_name, 678 m_child_processes_inherit, socket); 679 if (error_ptr) 680 *error_ptr = error; 681 m_write_sp.reset(socket); 682 m_read_sp = m_write_sp; 683 if (error.Fail()) { 684 return eConnectionStatusError; 685 } 686 m_uri.assign(socket_name); 687 return eConnectionStatusSuccess; 688} 689 690ConnectionStatus 691ConnectionFileDescriptor::SocketListenAndAccept(llvm::StringRef s, 692 Status *error_ptr) { 693 m_port_predicate.SetValue(0, eBroadcastNever); 694 695 Socket *socket = nullptr; 696 m_waiting_for_accept = true; 697 Status error = Socket::TcpListen(s, m_child_processes_inherit, socket, 698 &m_port_predicate); 699 if (error_ptr) 700 *error_ptr = error; 701 if (error.Fail()) 702 return eConnectionStatusError; 703 704 std::unique_ptr<Socket> listening_socket_up; 705 706 listening_socket_up.reset(socket); 707 socket = nullptr; 708 error = listening_socket_up->Accept(socket); 709 listening_socket_up.reset(); 710 if (error_ptr) 711 *error_ptr = error; 712 if (error.Fail()) 713 return eConnectionStatusError; 714 715 InitializeSocket(socket); 716 return eConnectionStatusSuccess; 717} 718 719ConnectionStatus ConnectionFileDescriptor::ConnectTCP(llvm::StringRef s, 720 Status *error_ptr) { 721 Socket *socket = nullptr; 722 Status error = Socket::TcpConnect(s, m_child_processes_inherit, socket); 723 if (error_ptr) 724 *error_ptr = error; 725 m_write_sp.reset(socket); 726 m_read_sp = m_write_sp; 727 if (error.Fail()) { 728 return eConnectionStatusError; 729 } 730 m_uri.assign(s); 731 return eConnectionStatusSuccess; 732} 733 734ConnectionStatus ConnectionFileDescriptor::ConnectUDP(llvm::StringRef s, 735 Status *error_ptr) { 736 Socket *socket = nullptr; 737 Status error = Socket::UdpConnect(s, m_child_processes_inherit, socket); 738 if (error_ptr) 739 *error_ptr = error; 740 m_write_sp.reset(socket); 741 m_read_sp = m_write_sp; 742 if (error.Fail()) { 743 return eConnectionStatusError; 744 } 745 m_uri.assign(s); 746 return eConnectionStatusSuccess; 747} 748 749uint16_t 750ConnectionFileDescriptor::GetListeningPort(const Timeout<std::micro> &timeout) { 751 auto Result = m_port_predicate.WaitForValueNotEqualTo(0, timeout); 752 return Result ? *Result : 0; 753} 754 755bool ConnectionFileDescriptor::GetChildProcessesInherit() const { 756 return m_child_processes_inherit; 757} 758 759void ConnectionFileDescriptor::SetChildProcessesInherit( 760 bool child_processes_inherit) { 761 m_child_processes_inherit = child_processes_inherit; 762} 763 764void ConnectionFileDescriptor::InitializeSocket(Socket *socket) { 765 assert(socket->GetSocketProtocol() == Socket::ProtocolTcp); 766 TCPSocket *tcp_socket = static_cast<TCPSocket *>(socket); 767 768 m_write_sp.reset(socket); 769 m_read_sp = m_write_sp; 770 StreamString strm; 771 strm.Printf("connect://%s:%u", tcp_socket->GetRemoteIPAddress().c_str(), 772 tcp_socket->GetRemotePortNumber()); 773 m_uri = strm.GetString(); 774} 775