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

source code of lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp