Stream.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include "Stream.h"
  8. #include <LibCore/System.h>
  9. #include <fcntl.h>
  10. #include <netdb.h>
  11. #include <sys/ioctl.h>
  12. #include <sys/socket.h>
  13. #include <sys/types.h>
  14. #include <unistd.h>
  15. #ifdef AK_OS_SERENITY
  16. # include <serenity.h>
  17. #endif
  18. #ifdef AK_OS_FREEBSD
  19. # include <sys/ucred.h>
  20. #endif
  21. namespace Core::Stream {
  22. ErrorOr<void> Stream::read_entire_buffer(Bytes buffer)
  23. {
  24. VERIFY(buffer.size());
  25. size_t nread = 0;
  26. do {
  27. if (is_eof())
  28. return Error::from_string_literal("Reached end-of-file before filling the entire buffer");
  29. auto result = read(buffer.slice(nread));
  30. if (result.is_error()) {
  31. if (result.error().is_errno() && result.error().code() == EINTR) {
  32. continue;
  33. }
  34. return result.release_error();
  35. }
  36. nread += result.value().size();
  37. } while (nread < buffer.size());
  38. return {};
  39. }
  40. ErrorOr<ByteBuffer> Stream::read_until_eof(size_t block_size)
  41. {
  42. return read_until_eof_impl(block_size);
  43. }
  44. ErrorOr<ByteBuffer> Stream::read_until_eof_impl(size_t block_size, size_t expected_file_size)
  45. {
  46. ByteBuffer data;
  47. data.ensure_capacity(expected_file_size);
  48. size_t total_read = 0;
  49. Bytes buffer;
  50. while (!is_eof()) {
  51. if (buffer.is_empty()) {
  52. buffer = TRY(data.get_bytes_for_writing(block_size));
  53. }
  54. auto nread = TRY(read(buffer)).size();
  55. total_read += nread;
  56. buffer = buffer.slice(nread);
  57. }
  58. data.resize(total_read);
  59. return data;
  60. }
  61. ErrorOr<void> Stream::discard(size_t discarded_bytes)
  62. {
  63. // Note: This was chosen arbitrarily.
  64. // Note: This can't be PAGE_SIZE because it is defined to sysconf() on Lagom.
  65. constexpr size_t continuous_read_size = 4096;
  66. Array<u8, continuous_read_size> buffer;
  67. while (discarded_bytes > 0) {
  68. if (is_eof())
  69. return Error::from_string_literal("Reached end-of-file before reading all discarded bytes");
  70. auto slice = TRY(read(buffer.span().slice(0, min(discarded_bytes, continuous_read_size))));
  71. discarded_bytes -= slice.size();
  72. }
  73. return {};
  74. }
  75. ErrorOr<void> Stream::write_entire_buffer(ReadonlyBytes buffer)
  76. {
  77. VERIFY(buffer.size());
  78. size_t nwritten = 0;
  79. do {
  80. auto result = write(buffer.slice(nwritten));
  81. if (result.is_error()) {
  82. if (result.error().is_errno() && result.error().code() == EINTR) {
  83. continue;
  84. }
  85. return result.release_error();
  86. }
  87. nwritten += result.value();
  88. } while (nwritten < buffer.size());
  89. return {};
  90. }
  91. ErrorOr<off_t> SeekableStream::tell() const
  92. {
  93. // Seek with 0 and SEEK_CUR does not modify anything despite the const_cast,
  94. // so it's safe to do this.
  95. return const_cast<SeekableStream*>(this)->seek(0, SeekMode::FromCurrentPosition);
  96. }
  97. ErrorOr<off_t> SeekableStream::size()
  98. {
  99. auto original_position = TRY(tell());
  100. auto seek_result = seek(0, SeekMode::FromEndPosition);
  101. if (seek_result.is_error()) {
  102. // Let's try to restore the original position, just in case.
  103. auto restore_result = seek(original_position, SeekMode::SetPosition);
  104. if (restore_result.is_error()) {
  105. dbgln("Core::SeekableStream::size: Couldn't restore initial position, stream might have incorrect position now!");
  106. }
  107. return seek_result.release_error();
  108. }
  109. TRY(seek(original_position, SeekMode::SetPosition));
  110. return seek_result.value();
  111. }
  112. ErrorOr<void> SeekableStream::discard(size_t discarded_bytes)
  113. {
  114. TRY(seek(discarded_bytes, SeekMode::FromCurrentPosition));
  115. return {};
  116. }
  117. ErrorOr<NonnullOwnPtr<File>> File::open(StringView filename, OpenMode mode, mode_t permissions)
  118. {
  119. auto file = TRY(adopt_nonnull_own_or_enomem(new (nothrow) File(mode)));
  120. TRY(file->open_path(filename, permissions));
  121. return file;
  122. }
  123. ErrorOr<NonnullOwnPtr<File>> File::adopt_fd(int fd, OpenMode mode, ShouldCloseFileDescriptor should_close_file_descriptor)
  124. {
  125. if (fd < 0) {
  126. return Error::from_errno(EBADF);
  127. }
  128. if (!has_any_flag(mode, OpenMode::ReadWrite)) {
  129. dbgln("Core::File::adopt_fd: Attempting to adopt a file with neither Read nor Write specified in mode");
  130. return Error::from_errno(EINVAL);
  131. }
  132. auto file = TRY(adopt_nonnull_own_or_enomem(new (nothrow) File(mode, should_close_file_descriptor)));
  133. file->m_fd = fd;
  134. return file;
  135. }
  136. ErrorOr<NonnullOwnPtr<File>> File::standard_input()
  137. {
  138. return File::adopt_fd(STDIN_FILENO, OpenMode::Read, ShouldCloseFileDescriptor::No);
  139. }
  140. ErrorOr<NonnullOwnPtr<File>> File::standard_output()
  141. {
  142. return File::adopt_fd(STDOUT_FILENO, OpenMode::Write, ShouldCloseFileDescriptor::No);
  143. }
  144. ErrorOr<NonnullOwnPtr<File>> File::standard_error()
  145. {
  146. return File::adopt_fd(STDERR_FILENO, OpenMode::Write, ShouldCloseFileDescriptor::No);
  147. }
  148. ErrorOr<NonnullOwnPtr<File>> File::open_file_or_standard_stream(StringView filename, OpenMode mode)
  149. {
  150. if (!filename.is_empty() && filename != "-"sv)
  151. return File::open(filename, mode);
  152. switch (mode) {
  153. case OpenMode::Read:
  154. return standard_input();
  155. case OpenMode::Write:
  156. return standard_output();
  157. default:
  158. VERIFY_NOT_REACHED();
  159. }
  160. }
  161. int File::open_mode_to_options(OpenMode mode)
  162. {
  163. int flags = 0;
  164. if (has_flag(mode, OpenMode::ReadWrite)) {
  165. flags |= O_RDWR | O_CREAT;
  166. } else if (has_flag(mode, OpenMode::Read)) {
  167. flags |= O_RDONLY;
  168. } else if (has_flag(mode, OpenMode::Write)) {
  169. flags |= O_WRONLY | O_CREAT;
  170. bool should_truncate = !has_any_flag(mode, OpenMode::Append | OpenMode::MustBeNew);
  171. if (should_truncate)
  172. flags |= O_TRUNC;
  173. }
  174. if (has_flag(mode, OpenMode::Append))
  175. flags |= O_APPEND;
  176. if (has_flag(mode, OpenMode::Truncate))
  177. flags |= O_TRUNC;
  178. if (has_flag(mode, OpenMode::MustBeNew))
  179. flags |= O_EXCL;
  180. if (!has_flag(mode, OpenMode::KeepOnExec))
  181. flags |= O_CLOEXEC;
  182. if (!has_flag(mode, OpenMode::Nonblocking))
  183. flags |= O_NONBLOCK;
  184. return flags;
  185. }
  186. ErrorOr<void> File::open_path(StringView filename, mode_t permissions)
  187. {
  188. VERIFY(m_fd == -1);
  189. auto flags = open_mode_to_options(m_mode);
  190. m_fd = TRY(System::open(filename, flags, permissions));
  191. return {};
  192. }
  193. ErrorOr<Bytes> File::read(Bytes buffer)
  194. {
  195. if (!has_flag(m_mode, OpenMode::Read)) {
  196. // NOTE: POSIX says that if the fd is not open for reading, the call
  197. // will return EBADF. Since we already know whether we can or
  198. // can't read the file, let's avoid a syscall.
  199. return Error::from_errno(EBADF);
  200. }
  201. ssize_t nread = TRY(System::read(m_fd, buffer));
  202. m_last_read_was_eof = nread == 0;
  203. return buffer.trim(nread);
  204. }
  205. ErrorOr<ByteBuffer> File::read_until_eof(size_t block_size)
  206. {
  207. // Note: This is used as a heuristic, it's not valid for devices or virtual files.
  208. auto const potential_file_size = TRY(System::fstat(m_fd)).st_size;
  209. return read_until_eof_impl(block_size, potential_file_size);
  210. }
  211. ErrorOr<size_t> File::write(ReadonlyBytes buffer)
  212. {
  213. if (!has_flag(m_mode, OpenMode::Write)) {
  214. // NOTE: Same deal as Read.
  215. return Error::from_errno(EBADF);
  216. }
  217. return TRY(System::write(m_fd, buffer));
  218. }
  219. bool File::is_eof() const { return m_last_read_was_eof; }
  220. bool File::is_open() const { return m_fd >= 0; }
  221. void File::close()
  222. {
  223. if (!is_open()) {
  224. return;
  225. }
  226. // NOTE: The closing of the file can be interrupted by a signal, in which
  227. // case EINTR will be returned by the close syscall. So let's try closing
  228. // the file until we aren't interrupted by rude signals. :^)
  229. ErrorOr<void> result;
  230. do {
  231. result = System::close(m_fd);
  232. } while (result.is_error() && result.error().code() == EINTR);
  233. VERIFY(!result.is_error());
  234. m_fd = -1;
  235. }
  236. ErrorOr<off_t> File::seek(i64 offset, SeekMode mode)
  237. {
  238. int syscall_mode;
  239. switch (mode) {
  240. case SeekMode::SetPosition:
  241. syscall_mode = SEEK_SET;
  242. break;
  243. case SeekMode::FromCurrentPosition:
  244. syscall_mode = SEEK_CUR;
  245. break;
  246. case SeekMode::FromEndPosition:
  247. syscall_mode = SEEK_END;
  248. break;
  249. default:
  250. VERIFY_NOT_REACHED();
  251. }
  252. off_t seek_result = TRY(System::lseek(m_fd, offset, syscall_mode));
  253. m_last_read_was_eof = false;
  254. return seek_result;
  255. }
  256. ErrorOr<void> File::truncate(off_t length)
  257. {
  258. return System::ftruncate(m_fd, length);
  259. }
  260. ErrorOr<int> Socket::create_fd(SocketDomain domain, SocketType type)
  261. {
  262. int socket_domain;
  263. switch (domain) {
  264. case SocketDomain::Inet:
  265. socket_domain = AF_INET;
  266. break;
  267. case SocketDomain::Local:
  268. socket_domain = AF_LOCAL;
  269. break;
  270. default:
  271. VERIFY_NOT_REACHED();
  272. }
  273. int socket_type;
  274. switch (type) {
  275. case SocketType::Stream:
  276. socket_type = SOCK_STREAM;
  277. break;
  278. case SocketType::Datagram:
  279. socket_type = SOCK_DGRAM;
  280. break;
  281. default:
  282. VERIFY_NOT_REACHED();
  283. }
  284. // Let's have a safe default of CLOEXEC. :^)
  285. #ifdef SOCK_CLOEXEC
  286. return System::socket(socket_domain, socket_type | SOCK_CLOEXEC, 0);
  287. #else
  288. auto fd = TRY(System::socket(socket_domain, socket_type, 0));
  289. TRY(System::fcntl(fd, F_SETFD, FD_CLOEXEC));
  290. return fd;
  291. #endif
  292. }
  293. ErrorOr<IPv4Address> Socket::resolve_host(DeprecatedString const& host, SocketType type)
  294. {
  295. int socket_type;
  296. switch (type) {
  297. case SocketType::Stream:
  298. socket_type = SOCK_STREAM;
  299. break;
  300. case SocketType::Datagram:
  301. socket_type = SOCK_DGRAM;
  302. break;
  303. default:
  304. VERIFY_NOT_REACHED();
  305. }
  306. struct addrinfo hints = {};
  307. hints.ai_family = AF_UNSPEC;
  308. hints.ai_socktype = socket_type;
  309. hints.ai_flags = 0;
  310. hints.ai_protocol = 0;
  311. auto const results = TRY(Core::System::getaddrinfo(host.characters(), nullptr, hints));
  312. for (auto const& result : results.addresses()) {
  313. if (result.ai_family == AF_INET) {
  314. auto* socket_address = bit_cast<struct sockaddr_in*>(result.ai_addr);
  315. NetworkOrdered<u32> const network_ordered_address { socket_address->sin_addr.s_addr };
  316. return IPv4Address { network_ordered_address };
  317. }
  318. }
  319. return Error::from_string_literal("Could not resolve to IPv4 address");
  320. }
  321. ErrorOr<void> Socket::connect_local(int fd, DeprecatedString const& path)
  322. {
  323. auto address = SocketAddress::local(path);
  324. auto maybe_sockaddr = address.to_sockaddr_un();
  325. if (!maybe_sockaddr.has_value()) {
  326. dbgln("Core::Stream::Socket::connect_local: Could not obtain a sockaddr_un");
  327. return Error::from_errno(EINVAL);
  328. }
  329. auto addr = maybe_sockaddr.release_value();
  330. return System::connect(fd, bit_cast<struct sockaddr*>(&addr), sizeof(addr));
  331. }
  332. ErrorOr<void> Socket::connect_inet(int fd, SocketAddress const& address)
  333. {
  334. auto addr = address.to_sockaddr_in();
  335. return System::connect(fd, bit_cast<struct sockaddr*>(&addr), sizeof(addr));
  336. }
  337. ErrorOr<Bytes> PosixSocketHelper::read(Bytes buffer, int flags)
  338. {
  339. if (!is_open()) {
  340. return Error::from_errno(ENOTCONN);
  341. }
  342. ssize_t nread = TRY(System::recv(m_fd, buffer.data(), buffer.size(), flags));
  343. m_last_read_was_eof = nread == 0;
  344. // If a socket read is EOF, then no more data can be read from it because
  345. // the protocol has disconnected. In this case, we can just disable the
  346. // notifier if we have one.
  347. if (m_last_read_was_eof && m_notifier)
  348. m_notifier->set_enabled(false);
  349. return buffer.trim(nread);
  350. }
  351. ErrorOr<size_t> PosixSocketHelper::write(ReadonlyBytes buffer, int flags)
  352. {
  353. if (!is_open()) {
  354. return Error::from_errno(ENOTCONN);
  355. }
  356. return TRY(System::send(m_fd, buffer.data(), buffer.size(), flags));
  357. }
  358. void PosixSocketHelper::close()
  359. {
  360. if (!is_open()) {
  361. return;
  362. }
  363. if (m_notifier)
  364. m_notifier->set_enabled(false);
  365. ErrorOr<void> result;
  366. do {
  367. result = System::close(m_fd);
  368. } while (result.is_error() && result.error().code() == EINTR);
  369. VERIFY(!result.is_error());
  370. m_fd = -1;
  371. }
  372. ErrorOr<bool> PosixSocketHelper::can_read_without_blocking(int timeout) const
  373. {
  374. struct pollfd the_fd = { .fd = m_fd, .events = POLLIN, .revents = 0 };
  375. ErrorOr<int> result { 0 };
  376. do {
  377. result = Core::System::poll({ &the_fd, 1 }, timeout);
  378. } while (result.is_error() && result.error().code() == EINTR);
  379. if (result.is_error())
  380. return result.release_error();
  381. return (the_fd.revents & POLLIN) > 0;
  382. }
  383. ErrorOr<void> PosixSocketHelper::set_blocking(bool enabled)
  384. {
  385. int value = enabled ? 0 : 1;
  386. return System::ioctl(m_fd, FIONBIO, &value);
  387. }
  388. ErrorOr<void> PosixSocketHelper::set_close_on_exec(bool enabled)
  389. {
  390. int flags = TRY(System::fcntl(m_fd, F_GETFD));
  391. if (enabled)
  392. flags |= FD_CLOEXEC;
  393. else
  394. flags &= ~FD_CLOEXEC;
  395. TRY(System::fcntl(m_fd, F_SETFD, flags));
  396. return {};
  397. }
  398. ErrorOr<void> PosixSocketHelper::set_receive_timeout(Time timeout)
  399. {
  400. auto timeout_spec = timeout.to_timespec();
  401. return System::setsockopt(m_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout_spec, sizeof(timeout_spec));
  402. }
  403. void PosixSocketHelper::setup_notifier()
  404. {
  405. if (!m_notifier)
  406. m_notifier = Core::Notifier::construct(m_fd, Core::Notifier::Read);
  407. }
  408. ErrorOr<NonnullOwnPtr<TCPSocket>> TCPSocket::connect(DeprecatedString const& host, u16 port)
  409. {
  410. auto ip_address = TRY(resolve_host(host, SocketType::Stream));
  411. return connect(SocketAddress { ip_address, port });
  412. }
  413. ErrorOr<NonnullOwnPtr<TCPSocket>> TCPSocket::connect(SocketAddress const& address)
  414. {
  415. auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) TCPSocket()));
  416. auto fd = TRY(create_fd(SocketDomain::Inet, SocketType::Stream));
  417. socket->m_helper.set_fd(fd);
  418. TRY(connect_inet(fd, address));
  419. socket->setup_notifier();
  420. return socket;
  421. }
  422. ErrorOr<NonnullOwnPtr<TCPSocket>> TCPSocket::adopt_fd(int fd)
  423. {
  424. if (fd < 0) {
  425. return Error::from_errno(EBADF);
  426. }
  427. auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) TCPSocket()));
  428. socket->m_helper.set_fd(fd);
  429. socket->setup_notifier();
  430. return socket;
  431. }
  432. ErrorOr<size_t> PosixSocketHelper::pending_bytes() const
  433. {
  434. if (!is_open()) {
  435. return Error::from_errno(ENOTCONN);
  436. }
  437. int value;
  438. TRY(System::ioctl(m_fd, FIONREAD, &value));
  439. return static_cast<size_t>(value);
  440. }
  441. ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(DeprecatedString const& host, u16 port, Optional<Time> timeout)
  442. {
  443. auto ip_address = TRY(resolve_host(host, SocketType::Datagram));
  444. return connect(SocketAddress { ip_address, port }, timeout);
  445. }
  446. ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(SocketAddress const& address, Optional<Time> timeout)
  447. {
  448. auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) UDPSocket()));
  449. auto fd = TRY(create_fd(SocketDomain::Inet, SocketType::Datagram));
  450. socket->m_helper.set_fd(fd);
  451. if (timeout.has_value()) {
  452. TRY(socket->m_helper.set_receive_timeout(timeout.value()));
  453. }
  454. TRY(connect_inet(fd, address));
  455. socket->setup_notifier();
  456. return socket;
  457. }
  458. ErrorOr<NonnullOwnPtr<LocalSocket>> LocalSocket::connect(DeprecatedString const& path, PreventSIGPIPE prevent_sigpipe)
  459. {
  460. auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) LocalSocket(prevent_sigpipe)));
  461. auto fd = TRY(create_fd(SocketDomain::Local, SocketType::Stream));
  462. socket->m_helper.set_fd(fd);
  463. TRY(connect_local(fd, path));
  464. socket->setup_notifier();
  465. return socket;
  466. }
  467. ErrorOr<NonnullOwnPtr<LocalSocket>> LocalSocket::adopt_fd(int fd, PreventSIGPIPE prevent_sigpipe)
  468. {
  469. if (fd < 0) {
  470. return Error::from_errno(EBADF);
  471. }
  472. auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) LocalSocket(prevent_sigpipe)));
  473. socket->m_helper.set_fd(fd);
  474. socket->setup_notifier();
  475. return socket;
  476. }
  477. ErrorOr<int> LocalSocket::receive_fd(int flags)
  478. {
  479. #if defined(AK_OS_SERENITY)
  480. return Core::System::recvfd(m_helper.fd(), flags);
  481. #elif defined(AK_OS_LINUX) || defined(AK_OS_MACOS)
  482. union {
  483. struct cmsghdr cmsghdr;
  484. char control[CMSG_SPACE(sizeof(int))];
  485. } cmsgu {};
  486. char c = 0;
  487. struct iovec iov {
  488. .iov_base = &c,
  489. .iov_len = 1,
  490. };
  491. struct msghdr msg = {};
  492. msg.msg_iov = &iov;
  493. msg.msg_iovlen = 1;
  494. msg.msg_control = cmsgu.control;
  495. msg.msg_controllen = sizeof(cmsgu.control);
  496. TRY(Core::System::recvmsg(m_helper.fd(), &msg, 0));
  497. struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  498. if (!cmsg || cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  499. return Error::from_string_literal("Malformed message when receiving file descriptor");
  500. VERIFY(cmsg->cmsg_level == SOL_SOCKET);
  501. VERIFY(cmsg->cmsg_type == SCM_RIGHTS);
  502. int fd = *((int*)CMSG_DATA(cmsg));
  503. if (flags & O_CLOEXEC) {
  504. auto fd_flags = TRY(Core::System::fcntl(fd, F_GETFD));
  505. TRY(Core::System::fcntl(fd, F_SETFD, fd_flags | FD_CLOEXEC));
  506. }
  507. return fd;
  508. #else
  509. (void)flags;
  510. return Error::from_string_literal("File descriptor passing not supported on this platform");
  511. #endif
  512. }
  513. ErrorOr<void> LocalSocket::send_fd(int fd)
  514. {
  515. #if defined(AK_OS_SERENITY)
  516. return Core::System::sendfd(m_helper.fd(), fd);
  517. #elif defined(AK_OS_LINUX) || defined(AK_OS_MACOS)
  518. char c = 'F';
  519. struct iovec iov {
  520. .iov_base = &c,
  521. .iov_len = sizeof(c)
  522. };
  523. union {
  524. struct cmsghdr cmsghdr;
  525. char control[CMSG_SPACE(sizeof(int))];
  526. } cmsgu {};
  527. struct msghdr msg = {};
  528. msg.msg_iov = &iov;
  529. msg.msg_iovlen = 1;
  530. msg.msg_control = cmsgu.control;
  531. msg.msg_controllen = sizeof(cmsgu.control);
  532. struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  533. cmsg->cmsg_len = CMSG_LEN(sizeof(int));
  534. cmsg->cmsg_level = SOL_SOCKET;
  535. cmsg->cmsg_type = SCM_RIGHTS;
  536. *((int*)CMSG_DATA(cmsg)) = fd;
  537. TRY(Core::System::sendmsg(m_helper.fd(), &msg, 0));
  538. return {};
  539. #else
  540. (void)fd;
  541. return Error::from_string_literal("File descriptor passing not supported on this platform");
  542. #endif
  543. }
  544. ErrorOr<pid_t> LocalSocket::peer_pid() const
  545. {
  546. #ifdef AK_OS_MACOS
  547. pid_t pid;
  548. socklen_t pid_size = sizeof(pid);
  549. #elif defined(AK_OS_FREEBSD)
  550. struct xucred creds = {};
  551. socklen_t creds_size = sizeof(creds);
  552. #elif defined(AK_OS_OPENBSD)
  553. struct sockpeercred creds = {};
  554. socklen_t creds_size = sizeof(creds);
  555. #else
  556. struct ucred creds = {};
  557. socklen_t creds_size = sizeof(creds);
  558. #endif
  559. #ifdef AK_OS_MACOS
  560. TRY(System::getsockopt(m_helper.fd(), SOL_LOCAL, LOCAL_PEERPID, &pid, &pid_size));
  561. return pid;
  562. #elif defined(AK_OS_FREEBSD)
  563. TRY(System::getsockopt(m_helper.fd(), SOL_LOCAL, LOCAL_PEERCRED, &creds, &creds_size));
  564. return creds.cr_pid;
  565. #else
  566. TRY(System::getsockopt(m_helper.fd(), SOL_SOCKET, SO_PEERCRED, &creds, &creds_size));
  567. return creds.pid;
  568. #endif
  569. }
  570. ErrorOr<Bytes> LocalSocket::read_without_waiting(Bytes buffer)
  571. {
  572. return m_helper.read(buffer, MSG_DONTWAIT);
  573. }
  574. Optional<int> LocalSocket::fd() const
  575. {
  576. if (!is_open())
  577. return {};
  578. return m_helper.fd();
  579. }
  580. ErrorOr<int> LocalSocket::release_fd()
  581. {
  582. if (!is_open()) {
  583. return Error::from_errno(ENOTCONN);
  584. }
  585. auto fd = m_helper.fd();
  586. m_helper.set_fd(-1);
  587. return fd;
  588. }
  589. WrappedAKInputStream::WrappedAKInputStream(NonnullOwnPtr<InputStream> stream)
  590. : m_stream(move(stream))
  591. {
  592. }
  593. ErrorOr<Bytes> WrappedAKInputStream::read(Bytes bytes)
  594. {
  595. auto bytes_read = m_stream->read(bytes);
  596. if (m_stream->has_any_error())
  597. return Error::from_string_literal("Underlying InputStream indicated an error");
  598. return bytes.slice(0, bytes_read);
  599. }
  600. ErrorOr<void> WrappedAKInputStream::discard(size_t discarded_bytes)
  601. {
  602. if (!m_stream->discard_or_error(discarded_bytes))
  603. return Error::from_string_literal("Underlying InputStream indicated an error");
  604. return {};
  605. }
  606. ErrorOr<size_t> WrappedAKInputStream::write(ReadonlyBytes)
  607. {
  608. VERIFY_NOT_REACHED();
  609. }
  610. bool WrappedAKInputStream::is_eof() const
  611. {
  612. return m_stream->unreliable_eof();
  613. }
  614. bool WrappedAKInputStream::is_open() const
  615. {
  616. return true;
  617. }
  618. void WrappedAKInputStream::close()
  619. {
  620. }
  621. WrappedAKOutputStream::WrappedAKOutputStream(NonnullOwnPtr<OutputStream> stream)
  622. : m_stream(move(stream))
  623. {
  624. }
  625. ErrorOr<Bytes> WrappedAKOutputStream::read(Bytes)
  626. {
  627. VERIFY_NOT_REACHED();
  628. }
  629. ErrorOr<size_t> WrappedAKOutputStream::write(ReadonlyBytes bytes)
  630. {
  631. auto bytes_written = m_stream->write(bytes);
  632. if (m_stream->has_any_error())
  633. return Error::from_string_literal("Underlying OutputStream indicated an error");
  634. return bytes_written;
  635. }
  636. bool WrappedAKOutputStream::is_eof() const
  637. {
  638. VERIFY_NOT_REACHED();
  639. }
  640. bool WrappedAKOutputStream::is_open() const
  641. {
  642. return true;
  643. }
  644. void WrappedAKOutputStream::close()
  645. {
  646. }
  647. WrapInAKInputStream::WrapInAKInputStream(Core::Stream::Stream& stream)
  648. : m_stream(stream)
  649. {
  650. }
  651. size_t WrapInAKInputStream::read(Bytes bytes)
  652. {
  653. if (has_any_error())
  654. return 0;
  655. auto data_or_error = m_stream.read(bytes);
  656. if (data_or_error.is_error()) {
  657. set_fatal_error();
  658. return 0;
  659. }
  660. return data_or_error.value().size();
  661. }
  662. bool WrapInAKInputStream::unreliable_eof() const
  663. {
  664. return m_stream.is_eof();
  665. }
  666. bool WrapInAKInputStream::read_or_error(Bytes bytes)
  667. {
  668. if (read(bytes) < bytes.size()) {
  669. set_fatal_error();
  670. return false;
  671. }
  672. return true;
  673. }
  674. bool WrapInAKInputStream::discard_or_error(size_t count)
  675. {
  676. auto maybe_error = m_stream.discard(count);
  677. if (maybe_error.is_error()) {
  678. set_fatal_error();
  679. return false;
  680. }
  681. return true;
  682. }
  683. WrapInAKOutputStream::WrapInAKOutputStream(Core::Stream::Stream& stream)
  684. : m_stream(stream)
  685. {
  686. }
  687. size_t WrapInAKOutputStream::write(ReadonlyBytes bytes)
  688. {
  689. if (has_any_error())
  690. return 0;
  691. auto length_or_error = m_stream.write(bytes);
  692. if (length_or_error.is_error()) {
  693. set_fatal_error();
  694. return 0;
  695. }
  696. return length_or_error.value();
  697. }
  698. bool WrapInAKOutputStream::write_or_error(ReadonlyBytes bytes)
  699. {
  700. if (write(bytes) < bytes.size()) {
  701. set_fatal_error();
  702. return false;
  703. }
  704. return true;
  705. }
  706. }