ConnectionFileDescriptor.cpp revision 263363
1//===-- ConnectionFileDescriptor.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/Core/ConnectionFileDescriptor.h" 18#include "lldb/Host/Config.h" 19#include "lldb/Host/SocketAddress.h" 20 21// C Includes 22#include <errno.h> 23#include <fcntl.h> 24#include <string.h> 25#include <stdlib.h> 26#include <sys/types.h> 27#ifndef LLDB_DISABLE_POSIX 28#include <arpa/inet.h> 29#include <netdb.h> 30#include <netinet/in.h> 31#include <netinet/tcp.h> 32#include <sys/socket.h> 33#include <sys/un.h> 34#include <termios.h> 35#include <unistd.h> 36#endif 37#ifdef _WIN32 38#include "lldb/Host/windows/windows.h" 39#include <winsock2.h> 40#include <WS2tcpip.h> 41#endif 42 43// C++ Includes 44// Other libraries and framework includes 45#include "llvm/Support/ErrorHandling.h" 46#if defined(__APPLE__) 47#include "llvm/ADT/SmallVector.h" 48#endif 49// Project includes 50#include "lldb/lldb-private-log.h" 51#include "lldb/Interpreter/Args.h" 52#include "lldb/Core/Communication.h" 53#include "lldb/Core/Log.h" 54#include "lldb/Core/RegularExpression.h" 55#include "lldb/Core/Timer.h" 56 57using namespace lldb; 58using namespace lldb_private; 59 60static bool 61DecodeHostAndPort (const char *host_and_port, 62 std::string &host_str, 63 std::string &port_str, 64 int32_t& port, 65 Error *error_ptr) 66{ 67 static RegularExpression g_regex ("([^:]+):([0-9]+)"); 68 RegularExpression::Match regex_match(2); 69 if (g_regex.Execute (host_and_port, ®ex_match)) 70 { 71 if (regex_match.GetMatchAtIndex (host_and_port, 1, host_str) && 72 regex_match.GetMatchAtIndex (host_and_port, 2, port_str)) 73 { 74 port = Args::StringToSInt32 (port_str.c_str(), INT32_MIN); 75 if (port != INT32_MIN) 76 { 77 if (error_ptr) 78 error_ptr->Clear(); 79 return true; 80 } 81 } 82 } 83 host_str.clear(); 84 port_str.clear(); 85 port = INT32_MIN; 86 if (error_ptr) 87 error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'", host_and_port); 88 return false; 89} 90 91ConnectionFileDescriptor::ConnectionFileDescriptor () : 92 Connection(), 93 m_fd_send (-1), 94 m_fd_recv (-1), 95 m_fd_send_type (eFDTypeFile), 96 m_fd_recv_type (eFDTypeFile), 97 m_udp_send_sockaddr (new SocketAddress()), 98 m_should_close_fd (false), 99 m_socket_timeout_usec(0), 100 m_pipe_read(-1), 101 m_pipe_write(-1), 102 m_mutex (Mutex::eMutexTypeRecursive), 103 m_shutting_down (false) 104{ 105 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT)); 106 if (log) 107 log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor ()", this); 108} 109 110ConnectionFileDescriptor::ConnectionFileDescriptor (int fd, bool owns_fd) : 111 Connection(), 112 m_fd_send (fd), 113 m_fd_recv (fd), 114 m_fd_send_type (eFDTypeFile), 115 m_fd_recv_type (eFDTypeFile), 116 m_udp_send_sockaddr (new SocketAddress()), 117 m_should_close_fd (owns_fd), 118 m_socket_timeout_usec(0), 119 m_pipe_read(-1), 120 m_pipe_write(-1), 121 m_mutex (Mutex::eMutexTypeRecursive), 122 m_shutting_down (false) 123{ 124 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT)); 125 if (log) 126 log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = %i, owns_fd = %i)", this, fd, owns_fd); 127 OpenCommandPipe (); 128} 129 130 131ConnectionFileDescriptor::~ConnectionFileDescriptor () 132{ 133 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT)); 134 if (log) 135 log->Printf ("%p ConnectionFileDescriptor::~ConnectionFileDescriptor ()", this); 136 Disconnect (NULL); 137 CloseCommandPipe (); 138} 139 140void 141ConnectionFileDescriptor::OpenCommandPipe () 142{ 143 CloseCommandPipe(); 144 145 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 146 // Make the command file descriptor here: 147 int filedes[2]; 148#ifndef LLDB_DISABLE_POSIX 149 int result = pipe (filedes); 150#else 151 int result = -1; 152#endif 153 if (result != 0) 154 { 155 if (log) 156 log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe () - could not make pipe: %s", 157 this, 158 strerror(errno)); 159 } 160 else 161 { 162 m_pipe_read = filedes[0]; 163 m_pipe_write = filedes[1]; 164 if (log) 165 log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe() - success readfd=%d writefd=%d", 166 this, 167 m_pipe_read, 168 m_pipe_write); 169 } 170} 171 172void 173ConnectionFileDescriptor::CloseCommandPipe () 174{ 175 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 176 if (log) 177 log->Printf ("%p ConnectionFileDescriptor::CloseCommandPipe()", 178 this); 179 180 if (m_pipe_read != -1) 181 { 182#ifdef _MSC_VER 183 llvm_unreachable("pipe close unsupported in MSVC"); 184#else 185 close (m_pipe_read); 186#endif 187 m_pipe_read = -1; 188 } 189 190 if (m_pipe_write != -1) 191 { 192#ifdef _MSC_VER 193 llvm_unreachable("pipe close unsupported in MSVC"); 194#else 195 close (m_pipe_write); 196#endif 197 m_pipe_write = -1; 198 } 199} 200 201bool 202ConnectionFileDescriptor::IsConnected () const 203{ 204 return m_fd_send >= 0 || m_fd_recv >= 0; 205} 206 207ConnectionStatus 208ConnectionFileDescriptor::Connect (const char *s, Error *error_ptr) 209{ 210 Mutex::Locker locker (m_mutex); 211 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 212 if (log) 213 log->Printf ("%p ConnectionFileDescriptor::Connect (url = '%s')", this, s); 214 215 OpenCommandPipe(); 216 217 if (s && s[0]) 218 { 219 char *end = NULL; 220 if (strstr(s, "listen://")) 221 { 222 // listen://HOST:PORT 223 unsigned long listen_port = ::strtoul(s + strlen("listen://"), &end, 0); 224 return SocketListen (listen_port, error_ptr); 225 } 226 else if (strstr(s, "unix-accept://")) 227 { 228 // unix://SOCKNAME 229 return NamedSocketAccept (s + strlen("unix-accept://"), error_ptr); 230 } 231 else if (strstr(s, "connect://")) 232 { 233 return ConnectTCP (s + strlen("connect://"), error_ptr); 234 } 235 else if (strstr(s, "tcp-connect://")) 236 { 237 return ConnectTCP (s + strlen("tcp-connect://"), error_ptr); 238 } 239 else if (strstr(s, "udp://")) 240 { 241 return ConnectUDP (s + strlen("udp://"), error_ptr); 242 } 243 else if (strstr(s, "fd://")) 244 { 245 // Just passing a native file descriptor within this current process 246 // that is already opened (possibly from a service or other source). 247 s += strlen ("fd://"); 248 bool success = false; 249 m_fd_send = m_fd_recv = Args::StringToSInt32 (s, -1, 0, &success); 250 251 if (success) 252 { 253 // We have what looks to be a valid file descriptor, but we 254 // should make sure it is. We currently are doing this by trying to 255 // get the flags from the file descriptor and making sure it 256 // isn't a bad fd. 257 errno = 0; 258#ifndef LLDB_DISABLE_POSIX 259 int flags = ::fcntl (m_fd_send, F_GETFL, 0); 260#else 261 int flags = -1; 262#endif 263 if (flags == -1 || errno == EBADF) 264 { 265 if (error_ptr) 266 error_ptr->SetErrorStringWithFormat ("stale file descriptor: %s", s); 267 m_fd_send = m_fd_recv = -1; 268 return eConnectionStatusError; 269 } 270 else 271 { 272 // Try and get a socket option from this file descriptor to 273 // see if this is a socket and set m_is_socket accordingly. 274 int resuse; 275 bool is_socket = GetSocketOption (m_fd_send, SOL_SOCKET, SO_REUSEADDR, resuse) == 0; 276 if (is_socket) 277 m_fd_send_type = m_fd_recv_type = eFDTypeSocket; 278 // Don't take ownership of a file descriptor that gets passed 279 // to us since someone else opened the file descriptor and 280 // handed it to us. 281 // TODO: Since are using a URL to open connection we should 282 // eventually parse options using the web standard where we 283 // have "fd://123?opt1=value;opt2=value" and we can have an 284 // option be "owns=1" or "owns=0" or something like this to 285 // allow us to specify this. For now, we assume we must 286 // assume we don't own it. 287 m_should_close_fd = false; 288 return eConnectionStatusSuccess; 289 } 290 } 291 292 if (error_ptr) 293 error_ptr->SetErrorStringWithFormat ("invalid file descriptor: \"fd://%s\"", s); 294 m_fd_send = m_fd_recv = -1; 295 return eConnectionStatusError; 296 } 297 else if (strstr(s, "file://")) 298 { 299 // file:///PATH 300 const char *path = s + strlen("file://"); 301#ifndef LLDB_DISABLE_POSIX 302 do 303 { 304 m_fd_send = m_fd_recv = ::open (path, O_RDWR); 305 } while (m_fd_send == -1 && errno == EINTR); 306 if (m_fd_send == -1) 307 { 308 if (error_ptr) 309 error_ptr->SetErrorToErrno(); 310 return eConnectionStatusError; 311 } 312 313 if (::isatty(m_fd_send)) 314 { 315 // Set up serial terminal emulation 316 struct termios options; 317 ::tcgetattr (m_fd_send, &options); 318 319 // Set port speed to maximum 320 ::cfsetospeed (&options, B115200); 321 ::cfsetispeed (&options, B115200); 322 323 // Raw input, disable echo and signals 324 options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); 325 326 // Make sure only one character is needed to return from a read 327 options.c_cc[VMIN] = 1; 328 options.c_cc[VTIME] = 0; 329 330 ::tcsetattr (m_fd_send, TCSANOW, &options); 331 } 332 333 int flags = ::fcntl (m_fd_send, F_GETFL, 0); 334 if (flags >= 0) 335 { 336 if ((flags & O_NONBLOCK) == 0) 337 { 338 flags |= O_NONBLOCK; 339 ::fcntl (m_fd_send, F_SETFL, flags); 340 } 341 } 342 m_should_close_fd = true; 343 return eConnectionStatusSuccess; 344#else 345 return eConnectionStatusError; 346#endif 347 } 348 if (error_ptr) 349 error_ptr->SetErrorStringWithFormat ("unsupported connection URL: '%s'", s); 350 return eConnectionStatusError; 351 } 352 if (error_ptr) 353 error_ptr->SetErrorString("invalid connect arguments"); 354 return eConnectionStatusError; 355} 356 357ConnectionStatus 358ConnectionFileDescriptor::Disconnect (Error *error_ptr) 359{ 360 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 361 if (log) 362 log->Printf ("%p ConnectionFileDescriptor::Disconnect ()", this); 363 364 ConnectionStatus status = eConnectionStatusSuccess; 365 366 if (m_fd_send < 0 && m_fd_recv < 0) 367 { 368 if (log) 369 log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Nothing to disconnect", this); 370 return eConnectionStatusSuccess; 371 } 372 373 // Try to get the ConnectionFileDescriptor's mutex. If we fail, that is quite likely 374 // because somebody is doing a blocking read on our file descriptor. If that's the case, 375 // then send the "q" char to the command file channel so the read will wake up and the connection 376 // will then know to shut down. 377 378 m_shutting_down = true; 379 380 Mutex::Locker locker; 381 bool got_lock= locker.TryLock (m_mutex); 382 383 if (!got_lock) 384 { 385 if (m_pipe_write != -1 ) 386 { 387 int result; 388 result = write (m_pipe_write, "q", 1); 389 if (log) 390 log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, sent 'q' to %d, result = %d.", this, m_pipe_write, result); 391 } 392 else if (log) 393 log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, but no command pipe is available.", this); 394 locker.Lock (m_mutex); 395 } 396 397 if (m_should_close_fd == true) 398 { 399 if (m_fd_send == m_fd_recv) 400 { 401 status = Close (m_fd_send, m_fd_send_type, error_ptr); 402 } 403 else 404 { 405 // File descriptors are the different, close both if needed 406 if (m_fd_send >= 0) 407 status = Close (m_fd_send, m_fd_send_type, error_ptr); 408 if (m_fd_recv >= 0) 409 { 410 ConnectionStatus recv_status = Close (m_fd_recv, m_fd_recv_type, error_ptr); 411 if (status == eConnectionStatusSuccess) 412 status = recv_status; 413 } 414 } 415 } 416 417 // Now set all our descriptors to invalid values. 418 419 m_fd_send = m_fd_recv = -1; 420 421 if (status != eConnectionStatusSuccess) 422 { 423 424 return status; 425 } 426 427 m_shutting_down = false; 428 return eConnectionStatusSuccess; 429} 430 431size_t 432ConnectionFileDescriptor::Read (void *dst, 433 size_t dst_len, 434 uint32_t timeout_usec, 435 ConnectionStatus &status, 436 Error *error_ptr) 437{ 438 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 439 if (log) 440 log->Printf ("%p ConnectionFileDescriptor::Read () ::read (fd = %i, dst = %p, dst_len = %" PRIu64 ")...", 441 this, m_fd_recv, dst, (uint64_t)dst_len); 442 443 Mutex::Locker locker; 444 bool got_lock = locker.TryLock (m_mutex); 445 if (!got_lock) 446 { 447 if (log) 448 log->Printf ("%p ConnectionFileDescriptor::Read () failed to get the connection lock.", 449 this); 450 if (error_ptr) 451 error_ptr->SetErrorString ("failed to get the connection lock for read."); 452 453 status = eConnectionStatusTimedOut; 454 return 0; 455 } 456 else if (m_shutting_down) 457 return eConnectionStatusError; 458 459 ssize_t bytes_read = 0; 460 461 status = BytesAvailable (timeout_usec, error_ptr); 462 if (status == eConnectionStatusSuccess) 463 { 464 do 465 { 466#ifndef LLDB_DISABLE_POSIX 467 bytes_read = ::read (m_fd_recv, dst, dst_len); 468#else 469 switch (m_fd_send_type) { 470 case eFDTypeSocket: 471 case eFDTypeSocketUDP: 472 bytes_read = ::recv (m_fd_recv, (char*)dst, dst_len, 0); 473 break; 474 default: 475 bytes_read = -1; 476 break; 477 478 } 479 480#endif 481 } while (bytes_read < 0 && errno == EINTR); 482 } 483 484 if (status != eConnectionStatusSuccess) 485 return 0; 486 487 Error error; 488 if (bytes_read == 0) 489 { 490 error.Clear(); // End-of-file. Do not automatically close; pass along for the end-of-file handlers. 491 status = eConnectionStatusEndOfFile; 492 } 493 else if (bytes_read < 0) 494 { 495 error.SetErrorToErrno(); 496 } 497 else 498 { 499 error.Clear(); 500 } 501 502 if (log) 503 log->Printf ("%p ConnectionFileDescriptor::Read () ::read (fd = %i, dst = %p, dst_len = %" PRIu64 ") => %" PRIi64 ", error = %s", 504 this, 505 m_fd_recv, 506 dst, 507 (uint64_t)dst_len, 508 (int64_t)bytes_read, 509 error.AsCString()); 510 511 if (error_ptr) 512 *error_ptr = error; 513 514 if (error.Fail()) 515 { 516 uint32_t error_value = error.GetError(); 517 switch (error_value) 518 { 519 case EAGAIN: // The file was marked for non-blocking I/O, and no data were ready to be read. 520 if (m_fd_recv_type == eFDTypeSocket || m_fd_recv_type == eFDTypeSocketUDP) 521 status = eConnectionStatusTimedOut; 522 else 523 status = eConnectionStatusSuccess; 524 return 0; 525 526 case EFAULT: // Buf points outside the allocated address space. 527 case EINTR: // A read from a slow device was interrupted before any data arrived by the delivery of a signal. 528 case EINVAL: // The pointer associated with fildes was negative. 529 case EIO: // An I/O error occurred while reading from the file system. 530 // The process group is orphaned. 531 // The file is a regular file, nbyte is greater than 0, 532 // the starting position is before the end-of-file, and 533 // the starting position is greater than or equal to the 534 // offset maximum established for the open file 535 // descriptor associated with fildes. 536 case EISDIR: // An attempt is made to read a directory. 537 case ENOBUFS: // An attempt to allocate a memory buffer fails. 538 case ENOMEM: // Insufficient memory is available. 539 status = eConnectionStatusError; 540 break; // Break to close.... 541 542 case ENOENT: // no such file or directory 543 case EBADF: // fildes is not a valid file or socket descriptor open for reading. 544 case ENXIO: // An action is requested of a device that does not exist.. 545 // A requested action cannot be performed by the device. 546 case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket. 547 case ENOTCONN: // A read is attempted on an unconnected socket. 548 status = eConnectionStatusLostConnection; 549 break; // Break to close.... 550 551 case ETIMEDOUT: // A transmission timeout occurs during a read attempt on a socket. 552 status = eConnectionStatusTimedOut; 553 return 0; 554 555 default: 556 if (log) 557 log->Printf("%p ConnectionFileDescriptor::Read (), unexpected error: %s", this, strerror(error_value)); 558 status = eConnectionStatusError; 559 break; // Break to close.... 560 561 } 562 563 return 0; 564 } 565 return bytes_read; 566} 567 568size_t 569ConnectionFileDescriptor::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr) 570{ 571 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 572 if (log) 573 log->Printf ("%p ConnectionFileDescriptor::Write (src = %p, src_len = %" PRIu64 ")", this, src, (uint64_t)src_len); 574 575 if (!IsConnected ()) 576 { 577 if (error_ptr) 578 error_ptr->SetErrorString("not connected"); 579 status = eConnectionStatusNoConnection; 580 return 0; 581 } 582 583 584 Error error; 585 586 ssize_t bytes_sent = 0; 587 588 switch (m_fd_send_type) 589 { 590#ifndef LLDB_DISABLE_POSIX 591 case eFDTypeFile: // Other FD requireing read/write 592 do 593 { 594 bytes_sent = ::write (m_fd_send, src, src_len); 595 } while (bytes_sent < 0 && errno == EINTR); 596 break; 597#endif 598 case eFDTypeSocket: // Socket requiring send/recv 599 do 600 { 601 bytes_sent = ::send (m_fd_send, (char*)src, src_len, 0); 602 } while (bytes_sent < 0 && errno == EINTR); 603 break; 604 605 case eFDTypeSocketUDP: // Unconnected UDP socket requiring sendto/recvfrom 606 assert (m_udp_send_sockaddr->GetFamily() != 0); 607 do 608 { 609 bytes_sent = ::sendto (m_fd_send, 610 (char*)src, 611 src_len, 612 0, 613 *m_udp_send_sockaddr, 614 m_udp_send_sockaddr->GetLength()); 615 } while (bytes_sent < 0 && errno == EINTR); 616 break; 617 } 618 619 if (bytes_sent < 0) 620 error.SetErrorToErrno (); 621 else 622 error.Clear (); 623 624 if (log) 625 { 626 switch (m_fd_send_type) 627 { 628 case eFDTypeFile: // Other FD requireing read/write 629 log->Printf ("%p ConnectionFileDescriptor::Write() ::write (fd = %i, src = %p, src_len = %" PRIu64 ") => %" PRIi64 " (error = %s)", 630 this, 631 m_fd_send, 632 src, 633 (uint64_t)src_len, 634 (int64_t)bytes_sent, 635 error.AsCString()); 636 break; 637 638 case eFDTypeSocket: // Socket requiring send/recv 639 log->Printf ("%p ConnectionFileDescriptor::Write() ::send (socket = %i, src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)", 640 this, 641 m_fd_send, 642 src, 643 (uint64_t)src_len, 644 (int64_t)bytes_sent, 645 error.AsCString()); 646 break; 647 648 case eFDTypeSocketUDP: // Unconnected UDP socket requiring sendto/recvfrom 649 log->Printf ("%p ConnectionFileDescriptor::Write() ::sendto (socket = %i, src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)", 650 this, 651 m_fd_send, 652 src, 653 (uint64_t)src_len, 654 (int64_t)bytes_sent, 655 error.AsCString()); 656 break; 657 } 658 } 659 660 if (error_ptr) 661 *error_ptr = error; 662 663 if (error.Fail()) 664 { 665 switch (error.GetError()) 666 { 667 case EAGAIN: 668 case EINTR: 669 status = eConnectionStatusSuccess; 670 return 0; 671 672 case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket. 673 case ENOTCONN: // A read is attempted on an unconnected socket. 674 status = eConnectionStatusLostConnection; 675 break; // Break to close.... 676 677 default: 678 status = eConnectionStatusError; 679 break; // Break to close.... 680 } 681 682 return 0; 683 } 684 685 status = eConnectionStatusSuccess; 686 return bytes_sent; 687} 688 689 690 691#if defined(__APPLE__) 692 693// This ConnectionFileDescriptor::BytesAvailable() uses select(). 694// 695// PROS: 696// - select is consistent across most unix platforms 697// - this Apple specific version allows for unlimited fds in the fd_sets by 698// setting the _DARWIN_UNLIMITED_SELECT define prior to including the 699// required header files. 700 701// CONS: 702// - Darwin only 703 704ConnectionStatus 705ConnectionFileDescriptor::BytesAvailable (uint32_t timeout_usec, Error *error_ptr) 706{ 707 // Don't need to take the mutex here separately since we are only called from Read. If we 708 // ever get used more generally we will need to lock here as well. 709 710 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 711 if (log) 712 log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)", this, timeout_usec); 713 struct timeval *tv_ptr; 714 struct timeval tv; 715 if (timeout_usec == UINT32_MAX) 716 { 717 // Infinite wait... 718 tv_ptr = NULL; 719 } 720 else 721 { 722 TimeValue time_value; 723 time_value.OffsetWithMicroSeconds (timeout_usec); 724 tv.tv_sec = time_value.seconds(); 725 tv.tv_usec = time_value.microseconds(); 726 tv_ptr = &tv; 727 } 728 729 // Make a copy of the file descriptors to make sure we don't 730 // have another thread change these values out from under us 731 // and cause problems in the loop below where like in FS_SET() 732 const int data_fd = m_fd_recv; 733 const int pipe_fd = m_pipe_read; 734 735 if (data_fd >= 0) 736 { 737 const bool have_pipe_fd = pipe_fd >= 0; 738 739 while (data_fd == m_fd_recv) 740 { 741 const int nfds = std::max<int>(data_fd, pipe_fd) + 1; 742 llvm::SmallVector<fd_set, 1> read_fds; 743 read_fds.resize((nfds/FD_SETSIZE) + 1); 744 for (size_t i=0; i<read_fds.size(); ++i) 745 FD_ZERO (&read_fds[i]); 746 // FD_SET doesn't bounds check, it just happily walks off the end 747 // but we have taken care of making the extra storage with our 748 // SmallVector of fd_set objects 749 FD_SET (data_fd, read_fds.data()); 750 if (have_pipe_fd) 751 FD_SET (pipe_fd, read_fds.data()); 752 753 Error error; 754 755 if (log) 756 { 757 if (have_pipe_fd) 758 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p)...", 759 this, nfds, data_fd, pipe_fd, tv_ptr); 760 else 761 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p)...", 762 this, nfds, data_fd, tv_ptr); 763 } 764 765 const int num_set_fds = ::select (nfds, read_fds.data(), NULL, NULL, tv_ptr); 766 if (num_set_fds < 0) 767 error.SetErrorToErrno(); 768 else 769 error.Clear(); 770 771 if (log) 772 { 773 if (have_pipe_fd) 774 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p) => %d, error = %s", 775 this, nfds, data_fd, pipe_fd, tv_ptr, num_set_fds, error.AsCString()); 776 else 777 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p) => %d, error = %s", 778 this, nfds, data_fd, tv_ptr, num_set_fds, error.AsCString()); 779 } 780 781 if (error_ptr) 782 *error_ptr = error; 783 784 if (error.Fail()) 785 { 786 switch (error.GetError()) 787 { 788 case EBADF: // One of the descriptor sets specified an invalid descriptor. 789 return eConnectionStatusLostConnection; 790 791 case EINVAL: // The specified time limit is invalid. One of its components is negative or too large. 792 default: // Other unknown error 793 return eConnectionStatusError; 794 795 case EAGAIN: // The kernel was (perhaps temporarily) unable to 796 // allocate the requested number of file descriptors, 797 // or we have non-blocking IO 798 case EINTR: // A signal was delivered before the time limit 799 // expired and before any of the selected events 800 // occurred. 801 break; // Lets keep reading to until we timeout 802 } 803 } 804 else if (num_set_fds == 0) 805 { 806 return eConnectionStatusTimedOut; 807 } 808 else if (num_set_fds > 0) 809 { 810 // FD_ISSET is happy to deal with a something larger than 811 // a single fd_set. 812 if (FD_ISSET(data_fd, read_fds.data())) 813 return eConnectionStatusSuccess; 814 if (have_pipe_fd && FD_ISSET(pipe_fd, read_fds.data())) 815 { 816 // We got a command to exit. Read the data from that pipe: 817 char buffer[16]; 818 ssize_t bytes_read; 819 820 do 821 { 822 bytes_read = ::read (pipe_fd, buffer, sizeof(buffer)); 823 } while (bytes_read < 0 && errno == EINTR); 824 assert (bytes_read == 1 && buffer[0] == 'q'); 825 826 if (log) 827 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.", 828 this, (int) bytes_read, buffer); 829 830 return eConnectionStatusEndOfFile; 831 } 832 } 833 } 834 } 835 836 if (error_ptr) 837 error_ptr->SetErrorString("not connected"); 838 return eConnectionStatusLostConnection; 839} 840 841#else 842 843// This ConnectionFileDescriptor::BytesAvailable() uses select(). 844// 845// PROS: 846// - select is consistent across most unix platforms 847// CONS: 848// - only supports file descriptors up to FD_SETSIZE. This implementation 849// will assert if it runs into that hard limit to let users know that 850// another ConnectionFileDescriptor::BytesAvailable() should be used 851// or a new version of ConnectionFileDescriptor::BytesAvailable() should 852// be written for the system that is running into the limitations. MacOSX 853// uses kqueues, and there is a poll() based implementation below. 854 855ConnectionStatus 856ConnectionFileDescriptor::BytesAvailable (uint32_t timeout_usec, Error *error_ptr) 857{ 858 // Don't need to take the mutex here separately since we are only called from Read. If we 859 // ever get used more generally we will need to lock here as well. 860 861 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 862 if (log) 863 log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)", this, timeout_usec); 864 struct timeval *tv_ptr; 865 struct timeval tv; 866 if (timeout_usec == UINT32_MAX) 867 { 868 // Infinite wait... 869 tv_ptr = NULL; 870 } 871 else 872 { 873 TimeValue time_value; 874 time_value.OffsetWithMicroSeconds (timeout_usec); 875 tv.tv_sec = time_value.seconds(); 876 tv.tv_usec = time_value.microseconds(); 877 tv_ptr = &tv; 878 } 879 880 // Make a copy of the file descriptors to make sure we don't 881 // have another thread change these values out from under us 882 // and cause problems in the loop below where like in FS_SET() 883 const int data_fd = m_fd_recv; 884 const int pipe_fd = m_pipe_read; 885 886 if (data_fd >= 0) 887 { 888 // If this assert fires off on MacOSX, we will need to switch to using 889 // libdispatch to read from file descriptors because poll() is causing 890 // kernel panics and if we exceed FD_SETSIZE we will have no choice... 891#ifndef _MSC_VER 892 assert (data_fd < FD_SETSIZE); 893#endif 894 895 const bool have_pipe_fd = pipe_fd >= 0; 896 897 if (have_pipe_fd) 898 { 899 assert (pipe_fd < FD_SETSIZE); 900 } 901 902 while (data_fd == m_fd_recv) 903 { 904 fd_set read_fds; 905 FD_ZERO (&read_fds); 906 FD_SET (data_fd, &read_fds); 907 if (have_pipe_fd) 908 FD_SET (pipe_fd, &read_fds); 909 910 const int nfds = std::max<int>(data_fd, pipe_fd) + 1; 911 912 Error error; 913 914 if (log) 915 { 916 if (have_pipe_fd) 917 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p)...", 918 this, nfds, data_fd, pipe_fd, tv_ptr); 919 else 920 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p)...", 921 this, nfds, data_fd, tv_ptr); 922 } 923 924 const int num_set_fds = ::select (nfds, &read_fds, NULL, NULL, tv_ptr); 925 if (num_set_fds < 0) 926 error.SetErrorToErrno(); 927 else 928 error.Clear(); 929 930 if (log) 931 { 932 if (have_pipe_fd) 933 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p) => %d, error = %s", 934 this, nfds, data_fd, pipe_fd, tv_ptr, num_set_fds, error.AsCString()); 935 else 936 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p) => %d, error = %s", 937 this, nfds, data_fd, tv_ptr, num_set_fds, error.AsCString()); 938 } 939 940 if (error_ptr) 941 *error_ptr = error; 942 943 if (error.Fail()) 944 { 945 switch (error.GetError()) 946 { 947 case EBADF: // One of the descriptor sets specified an invalid descriptor. 948 return eConnectionStatusLostConnection; 949 950 case EINVAL: // The specified time limit is invalid. One of its components is negative or too large. 951 default: // Other unknown error 952 return eConnectionStatusError; 953 954 case EAGAIN: // The kernel was (perhaps temporarily) unable to 955 // allocate the requested number of file descriptors, 956 // or we have non-blocking IO 957 case EINTR: // A signal was delivered before the time limit 958 // expired and before any of the selected events 959 // occurred. 960 break; // Lets keep reading to until we timeout 961 } 962 } 963 else if (num_set_fds == 0) 964 { 965 return eConnectionStatusTimedOut; 966 } 967 else if (num_set_fds > 0) 968 { 969 if (FD_ISSET(data_fd, &read_fds)) 970 return eConnectionStatusSuccess; 971 if (have_pipe_fd && FD_ISSET(pipe_fd, &read_fds)) 972 { 973 // We got a command to exit. Read the data from that pipe: 974 char buffer[16]; 975 ssize_t bytes_read; 976 977 do 978 { 979 bytes_read = ::read (pipe_fd, buffer, sizeof(buffer)); 980 } while (bytes_read < 0 && errno == EINTR); 981 assert (bytes_read == 1 && buffer[0] == 'q'); 982 983 if (log) 984 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.", 985 this, (int) bytes_read, buffer); 986 987 return eConnectionStatusEndOfFile; 988 } 989 } 990 } 991 } 992 993 if (error_ptr) 994 error_ptr->SetErrorString("not connected"); 995 return eConnectionStatusLostConnection; 996} 997 998#endif 999 1000#if 0 1001#include <poll.h> 1002 1003// This ConnectionFileDescriptor::BytesAvailable() uses poll(). poll() should NOT 1004// be used on MacOSX as it has all sorts of restrictions on the types of file descriptors 1005// that it doesn't support. 1006// 1007// There may be some systems that properly support poll() that could use this 1008// implementation. I will let each system opt into this on their own. 1009// 1010// PROS: 1011// - no restrictions on the fd value that is used 1012// CONS: 1013// - varies wildly from platform to platform in its implementation restrictions 1014 1015ConnectionStatus 1016ConnectionFileDescriptor::BytesAvailable (uint32_t timeout_usec, Error *error_ptr) 1017{ 1018 // Don't need to take the mutex here separately since we are only called from Read. If we 1019 // ever get used more generally we will need to lock here as well. 1020 1021 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 1022 if (log) 1023 log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)", this, timeout_usec); 1024 int timeout_msec = 0; 1025 if (timeout_usec == UINT32_MAX) 1026 { 1027 // Infinite wait... 1028 timeout_msec = -1; 1029 } 1030 else if (timeout_usec == 0) 1031 { 1032 // Return immediately, don't wait 1033 timeout_msec = 0; 1034 } 1035 else 1036 { 1037 // Convert usec to msec 1038 timeout_msec = (timeout_usec + 999) / 1000; 1039 } 1040 1041 // Make a copy of the file descriptors to make sure we don't 1042 // have another thread change these values out from under us 1043 // and cause problems in the loop below where like in FS_SET() 1044 const int data_fd = m_fd_recv; 1045 const int pipe_fd = m_pipe_read; 1046 1047 // Make sure the file descriptor can be used with select as it 1048 // must be in range 1049 if (data_fd >= 0) 1050 { 1051 const bool have_pipe_fd = pipe_fd >= 0; 1052 struct pollfd fds[2] = 1053 { 1054 { data_fd, POLLIN, 0 }, 1055 { pipe_fd, POLLIN, 0 } 1056 }; 1057 const int nfds = have_pipe_fd ? 2 : 1; 1058 Error error; 1059 while (data_fd == m_fd_recv) 1060 { 1061 const int num_set_fds = ::poll (fds, nfds, timeout_msec); 1062 1063 if (num_set_fds < 0) 1064 error.SetErrorToErrno(); 1065 else 1066 error.Clear(); 1067 1068 if (error_ptr) 1069 *error_ptr = error; 1070 1071 if (log) 1072 { 1073 if (have_pipe_fd) 1074 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::poll (fds={{%i,POLLIN},{%i,POLLIN}}, nfds=%i, timeout_ms=%i) => %d, error = %s\n", 1075 this, 1076 data_fd, 1077 pipe_fd, 1078 nfds, 1079 timeout_msec, 1080 num_set_fds, 1081 error.AsCString()); 1082 else 1083 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::poll (fds={{%i,POLLIN}}, nfds=%i, timeout_ms=%i) => %d, error = %s\n", 1084 this, 1085 data_fd, 1086 nfds, 1087 timeout_msec, 1088 num_set_fds, 1089 error.AsCString()); 1090 } 1091 1092 if (error.Fail()) 1093 { 1094 switch (error.GetError()) 1095 { 1096 case EBADF: // One of the descriptor sets specified an invalid descriptor. 1097 return eConnectionStatusLostConnection; 1098 1099 case EINVAL: // The specified time limit is invalid. One of its components is negative or too large. 1100 default: // Other unknown error 1101 return eConnectionStatusError; 1102 1103 case EAGAIN: // The kernel was (perhaps temporarily) unable to 1104 // allocate the requested number of file descriptors, 1105 // or we have non-blocking IO 1106 case EINTR: // A signal was delivered before the time limit 1107 // expired and before any of the selected events 1108 // occurred. 1109 break; // Lets keep reading to until we timeout 1110 } 1111 } 1112 else if (num_set_fds == 0) 1113 { 1114 return eConnectionStatusTimedOut; 1115 } 1116 else if (num_set_fds > 0) 1117 { 1118 if (fds[0].revents & POLLIN) 1119 return eConnectionStatusSuccess; 1120 if (fds[1].revents & POLLIN) 1121 { 1122 // We got a command to exit. Read the data from that pipe: 1123 char buffer[16]; 1124 ssize_t bytes_read; 1125 1126 do 1127 { 1128 bytes_read = ::read (pipe_fd, buffer, sizeof(buffer)); 1129 } while (bytes_read < 0 && errno == EINTR); 1130 assert (bytes_read == 1 && buffer[0] == 'q'); 1131 1132 if (log) 1133 log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.", 1134 this, (int) bytes_read, buffer); 1135 1136 return eConnectionStatusEndOfFile; 1137 } 1138 } 1139 } 1140 } 1141 if (error_ptr) 1142 error_ptr->SetErrorString("not connected"); 1143 return eConnectionStatusLostConnection; 1144} 1145 1146#endif 1147 1148ConnectionStatus 1149ConnectionFileDescriptor::Close (int& fd, FDType type, Error *error_ptr) 1150{ 1151 if (error_ptr) 1152 error_ptr->Clear(); 1153 bool success = true; 1154 // Avoid taking a lock if we can 1155 if (fd >= 0) 1156 { 1157 Mutex::Locker locker (m_mutex); 1158 // Check the FD after the lock is taken to ensure only one thread 1159 // can get into the close scope below 1160 if (fd >= 0) 1161 { 1162 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 1163 if (log) 1164 log->Printf ("%p ConnectionFileDescriptor::Close (fd = %i)", this,fd); 1165#if _WIN32 1166 if (type != eFDTypeFile) 1167 success = closesocket(fd) == 0; 1168 else 1169#endif 1170 success = ::close (fd) == 0; 1171 // A reference to a FD was passed in, set it to an invalid value 1172 fd = -1; 1173 if (!success && error_ptr) 1174 { 1175 // Only set the error if we have been asked to since something else 1176 // might have caused us to try and shut down the connection and may 1177 // have already set the error. 1178 error_ptr->SetErrorToErrno(); 1179 } 1180 } 1181 } 1182 if (success) 1183 return eConnectionStatusSuccess; 1184 else 1185 return eConnectionStatusError; 1186} 1187 1188ConnectionStatus 1189ConnectionFileDescriptor::NamedSocketAccept (const char *socket_name, Error *error_ptr) 1190{ 1191#ifndef LLDB_DISABLE_POSIX 1192 ConnectionStatus result = eConnectionStatusError; 1193 struct sockaddr_un saddr_un; 1194 1195 m_fd_send_type = m_fd_recv_type = eFDTypeSocket; 1196 1197 int listen_socket = ::socket (AF_UNIX, SOCK_STREAM, 0); 1198 if (listen_socket == -1) 1199 { 1200 if (error_ptr) 1201 error_ptr->SetErrorToErrno(); 1202 return eConnectionStatusError; 1203 } 1204 1205 saddr_un.sun_family = AF_UNIX; 1206 ::strncpy(saddr_un.sun_path, socket_name, sizeof(saddr_un.sun_path) - 1); 1207 saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0'; 1208#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) 1209 saddr_un.sun_len = SUN_LEN (&saddr_un); 1210#endif 1211 1212 if (::bind (listen_socket, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) == 0) 1213 { 1214 if (::listen (listen_socket, 5) == 0) 1215 { 1216 m_fd_send = m_fd_recv = ::accept (listen_socket, NULL, 0); 1217 if (m_fd_send > 0) 1218 { 1219 m_should_close_fd = true; 1220 1221 if (error_ptr) 1222 error_ptr->Clear(); 1223 result = eConnectionStatusSuccess; 1224 } 1225 } 1226 } 1227 1228 if (result != eConnectionStatusSuccess) 1229 { 1230 if (error_ptr) 1231 error_ptr->SetErrorToErrno(); 1232 } 1233 // We are done with the listen port 1234 Close (listen_socket, eFDTypeSocket, NULL); 1235 return result; 1236#else 1237 return eConnectionStatusError; 1238#endif 1239} 1240 1241ConnectionStatus 1242ConnectionFileDescriptor::NamedSocketConnect (const char *socket_name, Error *error_ptr) 1243{ 1244#ifndef LLDB_DISABLE_POSIX 1245 Disconnect (NULL); 1246 m_fd_send_type = m_fd_recv_type = eFDTypeSocket; 1247 1248 // Open the socket that was passed in as an option 1249 struct sockaddr_un saddr_un; 1250 m_fd_send = m_fd_recv = ::socket (AF_UNIX, SOCK_STREAM, 0); 1251 if (m_fd_send == -1) 1252 { 1253 if (error_ptr) 1254 error_ptr->SetErrorToErrno(); 1255 return eConnectionStatusError; 1256 } 1257 1258 saddr_un.sun_family = AF_UNIX; 1259 ::strncpy(saddr_un.sun_path, socket_name, sizeof(saddr_un.sun_path) - 1); 1260 saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0'; 1261#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) 1262 saddr_un.sun_len = SUN_LEN (&saddr_un); 1263#endif 1264 1265 if (::connect (m_fd_send, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0) 1266 { 1267 if (error_ptr) 1268 error_ptr->SetErrorToErrno(); 1269 Disconnect (NULL); 1270 return eConnectionStatusError; 1271 } 1272 if (error_ptr) 1273 error_ptr->Clear(); 1274 return eConnectionStatusSuccess; 1275#else 1276 return eConnectionStatusError; 1277#endif 1278} 1279 1280ConnectionStatus 1281ConnectionFileDescriptor::SocketListen (uint16_t listen_port_num, Error *error_ptr) 1282{ 1283 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 1284 if (log) 1285 log->Printf ("%p ConnectionFileDescriptor::SocketListen (port = %i)", this, listen_port_num); 1286 1287 Disconnect (NULL); 1288 m_fd_send_type = m_fd_recv_type = eFDTypeSocket; 1289 int listen_port = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); 1290 if (listen_port == -1) 1291 { 1292 if (error_ptr) 1293 error_ptr->SetErrorToErrno(); 1294 return eConnectionStatusError; 1295 } 1296 1297 // enable local address reuse 1298 SetSocketOption (listen_port, SOL_SOCKET, SO_REUSEADDR, 1); 1299 1300 SocketAddress localhost; 1301 if (localhost.SetToLocalhost (AF_INET, listen_port_num)) 1302 { 1303 int err = ::bind (listen_port, localhost, localhost.GetLength()); 1304 if (err == -1) 1305 { 1306 if (error_ptr) 1307 error_ptr->SetErrorToErrno(); 1308 Close (listen_port, eFDTypeSocket, NULL); 1309 return eConnectionStatusError; 1310 } 1311 1312 err = ::listen (listen_port, 1); 1313 if (err == -1) 1314 { 1315 if (error_ptr) 1316 error_ptr->SetErrorToErrno(); 1317 Close (listen_port, eFDTypeSocket, NULL); 1318 return eConnectionStatusError; 1319 } 1320 1321 m_fd_send = m_fd_recv = ::accept (listen_port, NULL, 0); 1322 if (m_fd_send == -1) 1323 { 1324 if (error_ptr) 1325 error_ptr->SetErrorToErrno(); 1326 Close (listen_port, eFDTypeSocket, NULL); 1327 return eConnectionStatusError; 1328 } 1329 } 1330 1331 // We are done with the listen port 1332 Close (listen_port, eFDTypeSocket, NULL); 1333 1334 m_should_close_fd = true; 1335 1336 // Keep our TCP packets coming without any delays. 1337 SetSocketOption (m_fd_send, IPPROTO_TCP, TCP_NODELAY, 1); 1338 if (error_ptr) 1339 error_ptr->Clear(); 1340 return eConnectionStatusSuccess; 1341} 1342 1343ConnectionStatus 1344ConnectionFileDescriptor::ConnectTCP (const char *host_and_port, Error *error_ptr) 1345{ 1346 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 1347 if (log) 1348 log->Printf ("%p ConnectionFileDescriptor::ConnectTCP (host/port = %s)", this, host_and_port); 1349 Disconnect (NULL); 1350 1351 m_fd_send_type = m_fd_recv_type = eFDTypeSocket; 1352 std::string host_str; 1353 std::string port_str; 1354 int32_t port = INT32_MIN; 1355 if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, error_ptr)) 1356 return eConnectionStatusError; 1357 1358 // Create the socket 1359 m_fd_send = m_fd_recv = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); 1360 if (m_fd_send == -1) 1361 { 1362 if (error_ptr) 1363 error_ptr->SetErrorToErrno(); 1364 return eConnectionStatusError; 1365 } 1366 1367 m_should_close_fd = true; 1368 1369 // Enable local address reuse 1370 SetSocketOption (m_fd_send, SOL_SOCKET, SO_REUSEADDR, 1); 1371 1372 struct sockaddr_in sa; 1373 ::memset (&sa, 0, sizeof (sa)); 1374 sa.sin_family = AF_INET; 1375 sa.sin_port = htons (port); 1376 1377 int inet_pton_result = ::inet_pton (AF_INET, host_str.c_str(), &sa.sin_addr); 1378 1379 if (inet_pton_result <= 0) 1380 { 1381 struct hostent *host_entry = gethostbyname (host_str.c_str()); 1382 if (host_entry) 1383 host_str = ::inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list); 1384 inet_pton_result = ::inet_pton (AF_INET, host_str.c_str(), &sa.sin_addr); 1385 if (inet_pton_result <= 0) 1386 { 1387 1388 if (error_ptr) 1389 { 1390 if (inet_pton_result == -1) 1391 error_ptr->SetErrorToErrno(); 1392 else 1393 error_ptr->SetErrorStringWithFormat("invalid host string: '%s'", host_str.c_str()); 1394 } 1395 Disconnect (NULL); 1396 1397 return eConnectionStatusError; 1398 } 1399 } 1400 1401 if (-1 == ::connect (m_fd_send, (const struct sockaddr *)&sa, sizeof(sa))) 1402 { 1403 if (error_ptr) 1404 error_ptr->SetErrorToErrno(); 1405 Disconnect (NULL); 1406 1407 return eConnectionStatusError; 1408 } 1409 1410 // Keep our TCP packets coming without any delays. 1411 SetSocketOption (m_fd_send, IPPROTO_TCP, TCP_NODELAY, 1); 1412 if (error_ptr) 1413 error_ptr->Clear(); 1414 return eConnectionStatusSuccess; 1415} 1416 1417ConnectionStatus 1418ConnectionFileDescriptor::ConnectUDP (const char *host_and_port, Error *error_ptr) 1419{ 1420 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION)); 1421 if (log) 1422 log->Printf ("%p ConnectionFileDescriptor::ConnectUDP (host/port = %s)", this, host_and_port); 1423 Disconnect (NULL); 1424 1425 m_fd_send_type = m_fd_recv_type = eFDTypeSocketUDP; 1426 1427 std::string host_str; 1428 std::string port_str; 1429 int32_t port = INT32_MIN; 1430 if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, error_ptr)) 1431 return eConnectionStatusError; 1432 1433 // Setup the receiving end of the UDP connection on this localhost 1434 // on port zero. After we bind to port zero we can read the port. 1435 m_fd_recv = ::socket (AF_INET, SOCK_DGRAM, 0); 1436 if (m_fd_recv == -1) 1437 { 1438 // Socket creation failed... 1439 if (error_ptr) 1440 error_ptr->SetErrorToErrno(); 1441 } 1442 else 1443 { 1444 // Socket was created, now lets bind to the requested port 1445 SocketAddress addr; 1446 addr.SetToLocalhost (AF_INET, 0); 1447 1448 if (::bind (m_fd_recv, addr, addr.GetLength()) == -1) 1449 { 1450 // Bind failed... 1451 if (error_ptr) 1452 error_ptr->SetErrorToErrno(); 1453 Disconnect (NULL); 1454 } 1455 } 1456 1457 if (m_fd_recv == -1) 1458 return eConnectionStatusError; 1459 1460 // At this point we have setup the recieve port, now we need to 1461 // setup the UDP send socket 1462 1463 struct addrinfo hints; 1464 struct addrinfo *service_info_list = NULL; 1465 1466 ::memset (&hints, 0, sizeof(hints)); 1467 hints.ai_family = AF_INET; 1468 hints.ai_socktype = SOCK_DGRAM; 1469 int err = ::getaddrinfo (host_str.c_str(), port_str.c_str(), &hints, &service_info_list); 1470 if (err != 0) 1471 { 1472 if (error_ptr) 1473 error_ptr->SetErrorStringWithFormat("getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)", 1474 host_str.c_str(), 1475 port_str.c_str(), 1476 err, 1477 gai_strerror(err)); 1478 Disconnect (NULL); 1479 return eConnectionStatusError; 1480 } 1481 1482 for (struct addrinfo *service_info_ptr = service_info_list; 1483 service_info_ptr != NULL; 1484 service_info_ptr = service_info_ptr->ai_next) 1485 { 1486 m_fd_send = ::socket (service_info_ptr->ai_family, 1487 service_info_ptr->ai_socktype, 1488 service_info_ptr->ai_protocol); 1489 1490 if (m_fd_send != -1) 1491 { 1492 *m_udp_send_sockaddr = service_info_ptr; 1493 break; 1494 } 1495 else 1496 continue; 1497 } 1498 1499 :: freeaddrinfo (service_info_list); 1500 1501 if (m_fd_send == -1) 1502 { 1503 Disconnect (NULL); 1504 return eConnectionStatusError; 1505 } 1506 1507 if (error_ptr) 1508 error_ptr->Clear(); 1509 1510 m_should_close_fd = true; 1511 return eConnectionStatusSuccess; 1512} 1513 1514#if defined(_WIN32) 1515typedef const char * set_socket_option_arg_type; 1516typedef char * get_socket_option_arg_type; 1517#else // #if defined(_WIN32) 1518typedef const void * set_socket_option_arg_type; 1519typedef void * get_socket_option_arg_type; 1520#endif // #if defined(_WIN32) 1521 1522int 1523ConnectionFileDescriptor::GetSocketOption(int fd, int level, int option_name, int &option_value) 1524{ 1525 get_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value); 1526 socklen_t option_value_size = sizeof(int); 1527 return ::getsockopt(fd, level, option_name, option_value_p, &option_value_size); 1528} 1529 1530int 1531ConnectionFileDescriptor::SetSocketOption(int fd, int level, int option_name, int option_value) 1532{ 1533 set_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value); 1534 return ::setsockopt(fd, level, option_name, option_value_p, sizeof(option_value)); 1535} 1536 1537bool 1538ConnectionFileDescriptor::SetSocketReceiveTimeout (uint32_t timeout_usec) 1539{ 1540 switch (m_fd_recv_type) 1541 { 1542 case eFDTypeFile: // Other FD requireing read/write 1543 break; 1544 1545 case eFDTypeSocket: // Socket requiring send/recv 1546 case eFDTypeSocketUDP: // Unconnected UDP socket requiring sendto/recvfrom 1547 { 1548 // Check in case timeout for m_fd has already been set to this value 1549 if (timeout_usec == m_socket_timeout_usec) 1550 return true; 1551 //printf ("ConnectionFileDescriptor::SetSocketReceiveTimeout (timeout_usec = %u)\n", timeout_usec); 1552 1553 struct timeval timeout; 1554 if (timeout_usec == UINT32_MAX) 1555 { 1556 timeout.tv_sec = 0; 1557 timeout.tv_usec = 0; 1558 } 1559 else if (timeout_usec == 0) 1560 { 1561 // Sending in zero does an infinite timeout, so set this as low 1562 // as we can go to get an effective zero timeout... 1563 timeout.tv_sec = 0; 1564 timeout.tv_usec = 1; 1565 } 1566 else 1567 { 1568 timeout.tv_sec = timeout_usec / TimeValue::MicroSecPerSec; 1569 timeout.tv_usec = timeout_usec % TimeValue::MicroSecPerSec; 1570 } 1571 if (::setsockopt (m_fd_recv, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<get_socket_option_arg_type>(&timeout), sizeof(timeout)) == 0) 1572 { 1573 m_socket_timeout_usec = timeout_usec; 1574 return true; 1575 } 1576 } 1577 } 1578 return false; 1579} 1580 1581in_port_t 1582ConnectionFileDescriptor::GetSocketPort (int fd) 1583{ 1584 // We bound to port zero, so we need to figure out which port we actually bound to 1585 SocketAddress sock_addr; 1586 socklen_t sock_addr_len = sock_addr.GetMaxLength (); 1587 if (::getsockname (fd, sock_addr, &sock_addr_len) == 0) 1588 return sock_addr.GetPort (); 1589 1590 return 0; 1591} 1592 1593// If the read file descriptor is a socket, then return 1594// the port number that is being used by the socket. 1595in_port_t 1596ConnectionFileDescriptor::GetReadPort () const 1597{ 1598 return ConnectionFileDescriptor::GetSocketPort (m_fd_recv); 1599} 1600 1601// If the write file descriptor is a socket, then return 1602// the port number that is being used by the socket. 1603in_port_t 1604ConnectionFileDescriptor::GetWritePort () const 1605{ 1606 return ConnectionFileDescriptor::GetSocketPort (m_fd_send); 1607} 1608 1609 1610