remote.cc (27574B)
1 #include "remote.hh" 2 3 #include "buffer_utils.hh" 4 #include "debug.hh" 5 #include "client_manager.hh" 6 #include "command_manager.hh" 7 #include "display_buffer.hh" 8 #include "event_manager.hh" 9 #include "file.hh" 10 #include "hash_map.hh" 11 #include "optional.hh" 12 #include "user_interface.hh" 13 #include "ranges.hh" 14 15 #include <sys/types.h> 16 #include <sys/socket.h> 17 #include <sys/un.h> 18 #include <sys/wait.h> 19 #include <unistd.h> 20 #include <stdio.h> 21 #include <string.h> 22 #include <pwd.h> 23 #include <fcntl.h> 24 #include <errno.h> 25 26 27 namespace Kakoune 28 { 29 30 enum class MessageType : uint8_t 31 { 32 Unknown, 33 Connect, 34 Command, 35 MenuShow, 36 MenuSelect, 37 MenuHide, 38 InfoShow, 39 InfoHide, 40 Draw, 41 DrawStatus, 42 Refresh, 43 SetOptions, 44 Exit, 45 Key, 46 Paste, 47 }; 48 49 class MsgWriter 50 { 51 public: 52 MsgWriter(RemoteBuffer& buffer, MessageType type) 53 : m_buffer{buffer}, m_start{(uint32_t)buffer.size()} 54 { 55 write_field(type); 56 write_field((uint32_t)0); // message size, to be patched on write 57 } 58 59 ~MsgWriter() 60 { 61 uint32_t count = (uint32_t)m_buffer.size() - m_start; 62 memcpy(m_buffer.data() + m_start + sizeof(MessageType), &count, sizeof(uint32_t)); 63 } 64 65 template<typename ...Args> 66 void write(Args&&... args) 67 { 68 (write_field(std::forward<Args>(args)), ...); 69 } 70 71 private: 72 void write_raw(const char* val, size_t size) 73 { 74 m_buffer.insert(m_buffer.end(), val, val + size); 75 } 76 77 template<typename T> 78 void write_field(const T& val) 79 { 80 static_assert(std::is_trivially_copyable<T>::value, ""); 81 write_raw((const char*)&val, sizeof(val)); 82 } 83 84 void write_field(StringView str) 85 { 86 write_field(str.length()); 87 write_raw(str.data(), (int)str.length()); 88 }; 89 90 void write_field(const String& str) 91 { 92 write_field(StringView{str}); 93 } 94 95 template<typename T> 96 void write_field(ConstArrayView<T> view) 97 { 98 write_field<uint32_t>(view.size()); 99 for (auto& val : view) 100 write_field(val); 101 } 102 103 template<typename T, MemoryDomain domain> 104 void write_field(const Vector<T, domain>& vec) 105 { 106 write_field(ConstArrayView<T>(vec)); 107 } 108 109 template<typename Key, typename Val, MemoryDomain domain> 110 void write_field(const HashMap<Key, Val, domain>& map) 111 { 112 write_field<uint32_t>(map.size()); 113 for (auto& val : map) 114 { 115 write_field(val.key); 116 write_field(val.value); 117 } 118 } 119 120 template<typename T> 121 void write_field(const Optional<T>& val) 122 { 123 write_field((bool)val); 124 if (val) 125 write_field(*val); 126 } 127 128 void write_field(Color color) 129 { 130 write_field(color.color); 131 if (color.isRGB()) 132 { 133 write_field(color.r); 134 write_field(color.g); 135 write_field(color.b); 136 } 137 } 138 139 void write_field(const DisplayAtom& atom) 140 { 141 write_field(atom.content()); 142 write_field(atom.face); 143 } 144 145 void write_field(const DisplayLine& line) 146 { 147 write_field(line.atoms()); 148 } 149 150 void write_field(const DisplayBuffer& display_buffer) 151 { 152 write_field(display_buffer.lines()); 153 } 154 155 private: 156 RemoteBuffer& m_buffer; 157 uint32_t m_start; 158 }; 159 160 class MsgReader 161 { 162 private: 163 template<typename T> 164 struct Reader { 165 static T read(MsgReader& reader) 166 { 167 static_assert(std::is_trivially_copyable<T>::value, ""); 168 T res; 169 reader.read(reinterpret_cast<char*>(&res), sizeof(T)); 170 return res; 171 } 172 }; 173 174 template<typename T, MemoryDomain domain> 175 struct Reader<Vector<T,domain>> { 176 static Vector<T, domain> read(MsgReader& reader) 177 { 178 uint32_t size = Reader<uint32_t>::read(reader); 179 Vector<T,domain> res; 180 res.reserve(size); 181 while (size--) 182 res.push_back(std::move(Reader<T>::read(reader))); 183 return res; 184 } 185 }; 186 187 template<typename T> 188 struct Reader<ArrayView<T>> : Reader<Vector<std::remove_cv_t<T>, MemoryDomain::Undefined>> {}; 189 190 template<typename Key, typename Value, MemoryDomain domain> 191 struct Reader<HashMap<Key, Value, domain>> { 192 static HashMap<Key, Value, domain> read(MsgReader& reader) 193 { 194 uint32_t size = Reader<uint32_t>::read(reader); 195 HashMap<Key, Value, domain> res; 196 res.reserve(size); 197 while (size--) 198 { 199 auto key = Reader<Key>::read(reader); 200 auto val = Reader<Value>::read(reader); 201 res.insert({std::move(key), std::move(val)}); 202 } 203 return res; 204 } 205 }; 206 207 template<typename T> 208 struct Reader<Optional<T>> { 209 static Optional<T> read(MsgReader& reader) 210 { 211 if (not Reader<bool>::read(reader)) 212 return {}; 213 return Reader<T>::read(reader); 214 } 215 }; 216 217 public: 218 void read_available(int sock) 219 { 220 if (m_write_pos < header_size) 221 { 222 m_stream.resize(header_size); 223 read_from_socket(sock, header_size - m_write_pos); 224 if (m_write_pos == header_size) 225 { 226 if (size() < header_size) 227 throw disconnected{"invalid message received"}; 228 m_stream.resize(size()); 229 } 230 } 231 else 232 read_from_socket(sock, size() - m_write_pos); 233 } 234 235 bool ready() const 236 { 237 return m_write_pos >= header_size and m_write_pos == size(); 238 } 239 240 uint32_t size() const 241 { 242 kak_assert(m_write_pos >= header_size); 243 uint32_t res; 244 memcpy(&res, m_stream.data() + sizeof(MessageType), sizeof(uint32_t)); 245 return res; 246 } 247 248 MessageType type() const 249 { 250 kak_assert(m_write_pos >= header_size); 251 return *reinterpret_cast<const MessageType*>(m_stream.data()); 252 } 253 254 void read(char* buffer, size_t size) 255 { 256 if (m_read_pos + size > m_stream.size()) 257 throw disconnected{"tried to read after message end"}; 258 memcpy(buffer, m_stream.data() + m_read_pos, size); 259 m_read_pos += size; 260 } 261 262 template<typename T> 263 auto read() 264 { 265 return Reader<T>::read(*this); 266 } 267 268 Optional<int> ancillary_fd() 269 { 270 auto res = m_ancillary_fd; 271 m_ancillary_fd.reset(); 272 return res; 273 } 274 275 ~MsgReader() 276 { 277 m_ancillary_fd.map(close); 278 } 279 280 void reset() 281 { 282 m_stream.resize(0); 283 m_write_pos = 0; 284 m_read_pos = header_size; 285 m_ancillary_fd.map(close); 286 } 287 288 private: 289 void read_from_socket(int sock, size_t size) 290 { 291 kak_assert(m_write_pos + size <= m_stream.size()); 292 iovec io{m_stream.data() + m_write_pos, size}; 293 alignas(cmsghdr) char fdbuf[CMSG_SPACE(sizeof(int))]; 294 295 msghdr msg{}; 296 msg.msg_iov = &io; 297 msg.msg_iovlen = 1; 298 msg.msg_control = fdbuf; 299 msg.msg_controllen = sizeof(fdbuf); 300 301 int res = recvmsg(sock, &msg, 0); 302 if (res <= 0) 303 throw disconnected{format("socket read failed: {}", strerror(errno))}; 304 305 m_write_pos += res; 306 307 if (cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); 308 cmsg and cmsg->cmsg_level == SOL_SOCKET and cmsg->cmsg_type == SCM_RIGHTS and cmsg->cmsg_len == CMSG_LEN(sizeof(int))) 309 { 310 m_ancillary_fd.map(close); 311 memcpy(&m_ancillary_fd.emplace(), CMSG_DATA(cmsg), sizeof(int)); 312 fcntl(*m_ancillary_fd, F_SETFD, FD_CLOEXEC); 313 } 314 } 315 316 static constexpr uint32_t header_size = sizeof(MessageType) + sizeof(uint32_t); 317 Vector<char, MemoryDomain::Remote> m_stream; 318 Optional<int> m_ancillary_fd; 319 uint32_t m_write_pos = 0; 320 uint32_t m_read_pos = header_size; 321 }; 322 323 template<> 324 struct MsgReader::Reader<String> { 325 static String read(MsgReader& reader) 326 { 327 ByteCount length = Reader<ByteCount>::read(reader); 328 String res; 329 if (length > 0) 330 { 331 res.force_size((int)length); 332 reader.read(&res[0_byte], (int)length); 333 } 334 return res; 335 } 336 }; 337 338 template<> 339 struct MsgReader::Reader<Color> { 340 static Color read(MsgReader& reader) 341 { 342 Color res; 343 res.color = Reader<Color::NamedColor>::read(reader); 344 if (res.isRGB()) 345 { 346 res.r = Reader<unsigned char>::read(reader); 347 res.g = Reader<unsigned char>::read(reader); 348 res.b = Reader<unsigned char>::read(reader); 349 } 350 return res; 351 } 352 }; 353 354 template<> 355 struct MsgReader::Reader<DisplayAtom> { 356 static DisplayAtom read(MsgReader& reader) 357 { 358 String content = Reader<String>::read(reader); 359 return {std::move(content), Reader<Face>::read(reader)}; 360 } 361 }; 362 363 template<> 364 struct MsgReader::Reader<DisplayLine> { 365 static DisplayLine read(MsgReader& reader) 366 { 367 return {Reader<Vector<DisplayAtom>>::read(reader)}; 368 } 369 }; 370 371 template<> 372 struct MsgReader::Reader<DisplayBuffer> { 373 static DisplayBuffer read(MsgReader& reader) 374 { 375 DisplayBuffer db; 376 db.lines() = Reader<Vector<DisplayLine>>::read(reader); 377 return db; 378 } 379 }; 380 381 382 class RemoteUI : public UserInterface 383 { 384 public: 385 RemoteUI(int socket, DisplayCoord dimensions); 386 ~RemoteUI() override; 387 388 bool is_ok() const override { return m_socket_watcher.fd() != -1; } 389 void menu_show(ConstArrayView<DisplayLine> choices, 390 DisplayCoord anchor, Face fg, Face bg, 391 MenuStyle style) override; 392 void menu_select(int selected) override; 393 void menu_hide() override; 394 395 void info_show(const DisplayLine& title, const DisplayLineList& content, 396 DisplayCoord anchor, Face face, 397 InfoStyle style) override; 398 void info_hide() override; 399 400 void draw(const DisplayBuffer& display_buffer, 401 DisplayCoord cursor_pos, 402 const Face& default_face, 403 const Face& padding_face, 404 ColumnCount widget_columns) override; 405 406 void draw_status(const DisplayLine& prompt, 407 const DisplayLine& content, 408 const ColumnCount cursor_pos, 409 const DisplayLine& mode_line, 410 const Face& default_face, 411 StatusStyle style) override; 412 413 void refresh(bool force) override; 414 415 DisplayCoord dimensions() override { return m_dimensions; } 416 417 void set_on_key(OnKeyCallback callback) override 418 { m_on_key = std::move(callback); } 419 420 void set_on_paste(OnPasteCallback callback) override 421 { m_on_paste = std::move(callback); } 422 423 void set_ui_options(const Options& options) override; 424 425 void exit(int status); 426 427 private: 428 template<typename ...Args> 429 void send_message(MessageType type, Args&&... args) 430 { 431 MsgWriter msg{m_send_buffer, type}; 432 msg.write(std::forward<Args>(args)...); 433 m_socket_watcher.events() |= FdEvents::Write; 434 } 435 436 FDWatcher m_socket_watcher; 437 MsgReader m_reader; 438 DisplayCoord m_dimensions; 439 OnKeyCallback m_on_key; 440 OnPasteCallback m_on_paste; 441 RemoteBuffer m_send_buffer; 442 }; 443 444 static bool send_data(int fd, RemoteBuffer& buffer, Optional<int> ancillary_fd = {}) 445 { 446 while (not buffer.empty() and fd_writable(fd)) 447 { 448 iovec io{buffer.data(), buffer.size()}; 449 alignas(cmsghdr) char fdbuf[CMSG_SPACE(sizeof(int))]; 450 451 msghdr msg{}; 452 msg.msg_iov = &io; 453 msg.msg_iovlen = 1; 454 if (ancillary_fd) 455 { 456 msg.msg_control = fdbuf; 457 msg.msg_controllen = sizeof(fdbuf); 458 459 cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); 460 cmsg->cmsg_len = CMSG_LEN(sizeof(int)); 461 cmsg->cmsg_level = SOL_SOCKET; 462 cmsg->cmsg_type = SCM_RIGHTS; 463 memcpy(CMSG_DATA(cmsg), &*ancillary_fd, sizeof(int)); 464 } 465 466 int res = sendmsg(fd, &msg, 0); 467 if (res <= 0) 468 throw disconnected{format("socket write failed: {}", strerror(errno))}; 469 buffer.erase(buffer.begin(), buffer.begin() + res); 470 } 471 return buffer.empty(); 472 } 473 474 RemoteUI::RemoteUI(int socket, DisplayCoord dimensions) 475 : m_socket_watcher(socket, FdEvents::Read | FdEvents::Write, EventMode::Urgent, 476 [this](FDWatcher& watcher, FdEvents events, EventMode) { 477 const int sock = watcher.fd(); 478 try 479 { 480 if (events & FdEvents::Write and send_data(sock, m_send_buffer)) 481 m_socket_watcher.events() &= ~FdEvents::Write; 482 483 while (events & FdEvents::Read and fd_readable(sock)) 484 { 485 m_reader.read_available(sock); 486 487 if (not m_reader.ready()) 488 continue; 489 490 if (m_reader.type() == MessageType::Key) 491 { 492 auto key = m_reader.read<Key>(); 493 m_reader.reset(); 494 if (key.modifiers == Key::Modifiers::Resize) 495 m_dimensions = key.coord(); 496 m_on_key(key); 497 } 498 else if (m_reader.type() == MessageType::Paste) 499 { 500 auto content = m_reader.read<String>(); 501 m_reader.reset(); 502 m_on_paste(content); 503 } 504 else 505 { 506 m_socket_watcher.close_fd(); 507 return; 508 } 509 } 510 } 511 catch (const disconnected& err) 512 { 513 write_to_debug_buffer(format("Error while transfering remote messages: {}", err.what())); 514 m_socket_watcher.close_fd(); 515 } 516 }), 517 m_dimensions(dimensions) 518 { 519 write_to_debug_buffer(format("remote client connected: {}", m_socket_watcher.fd())); 520 } 521 522 RemoteUI::~RemoteUI() 523 { 524 // Try to send the remaining data if possible, as it might contain the desired exit status 525 try 526 { 527 if (m_socket_watcher.fd() != -1) 528 send_data(m_socket_watcher.fd(), m_send_buffer); 529 } 530 catch (disconnected&) 531 { 532 } 533 534 write_to_debug_buffer(format("remote client disconnected: {}", m_socket_watcher.fd())); 535 m_socket_watcher.close_fd(); 536 } 537 538 void RemoteUI::menu_show(ConstArrayView<DisplayLine> choices, 539 DisplayCoord anchor, Face fg, Face bg, 540 MenuStyle style) 541 { 542 send_message(MessageType::MenuShow, choices, anchor, fg, bg, style); 543 } 544 545 void RemoteUI::menu_select(int selected) 546 { 547 send_message(MessageType::MenuSelect, selected); 548 } 549 550 void RemoteUI::menu_hide() 551 { 552 send_message(MessageType::MenuHide); 553 } 554 555 void RemoteUI::info_show(const DisplayLine& title, const DisplayLineList& content, 556 DisplayCoord anchor, Face face, 557 InfoStyle style) 558 { 559 send_message(MessageType::InfoShow, title, content, anchor, face, style); 560 } 561 562 void RemoteUI::info_hide() 563 { 564 send_message(MessageType::InfoHide); 565 } 566 567 void RemoteUI::draw(const DisplayBuffer& display_buffer, 568 DisplayCoord cursor_pos, 569 const Face& default_face, 570 const Face& padding_face, 571 ColumnCount widget_columns) 572 { 573 send_message(MessageType::Draw, display_buffer, cursor_pos, default_face, padding_face, widget_columns); 574 } 575 576 void RemoteUI::draw_status(const DisplayLine& prompt, 577 const DisplayLine& content, 578 const ColumnCount cursor_pos, 579 const DisplayLine& mode_line, 580 const Face& default_face, 581 StatusStyle style) 582 { 583 send_message(MessageType::DrawStatus, prompt, content, cursor_pos, mode_line, default_face, style); 584 } 585 586 void RemoteUI::refresh(bool force) 587 { 588 send_message(MessageType::Refresh, force); 589 } 590 591 void RemoteUI::set_ui_options(const Options& options) 592 { 593 send_message(MessageType::SetOptions, options); 594 } 595 596 void RemoteUI::exit(int status) 597 { 598 send_message(MessageType::Exit, status); 599 } 600 601 String get_user_name() 602 { 603 auto pw = getpwuid(geteuid()); 604 if (pw) 605 return pw->pw_name; 606 return getenv("USER"); 607 } 608 609 const String& session_directory() 610 { 611 static String session_dir = [] { 612 StringView xdg_runtime_dir = getenv("XDG_RUNTIME_DIR"); 613 if (not xdg_runtime_dir.empty()) 614 { 615 if (struct stat st; stat(xdg_runtime_dir.zstr(), &st) == 0 and st.st_uid == geteuid()) 616 return format("{}/kakoune", xdg_runtime_dir); 617 else 618 write_to_debug_buffer("XDG_RUNTIME_DIR does not exist or not owned by current user, using tmpdir"); 619 } 620 return format("{}/kakoune-{}", tmpdir(), get_user_name()); 621 }(); 622 return session_dir; 623 } 624 625 String session_path(StringView session, bool assume_valid) 626 { 627 if (not assume_valid and not all_of(session, is_identifier)) 628 throw runtime_error{format("invalid session name: '{}'", session)}; 629 String path = format("{}/{}", session_directory(), session); 630 if (not assume_valid and path.length() + 1 > sizeof sockaddr_un{}.sun_path) 631 throw runtime_error{format("socket path too long: '{}'", path)}; 632 return path; 633 } 634 635 static sockaddr_un session_addr(StringView session) 636 { 637 sockaddr_un addr; 638 addr.sun_family = AF_UNIX; 639 strcpy(addr.sun_path, session_path(session).c_str()); 640 return addr; 641 } 642 643 static int connect_to(StringView session) 644 { 645 int sock = socket(AF_UNIX, SOCK_STREAM, 0); 646 fcntl(sock, F_SETFD, FD_CLOEXEC); 647 sockaddr_un addr = session_addr(session); 648 if (connect(sock, (sockaddr*)&addr, sizeof(addr.sun_path)) == -1) 649 throw disconnected(format("connect to {} failed", addr.sun_path)); 650 return sock; 651 } 652 653 bool check_session(StringView session) 654 { 655 int sock = socket(AF_UNIX, SOCK_STREAM, 0); 656 auto close_sock = OnScopeEnd([sock]{ close(sock); }); 657 sockaddr_un addr = session_addr(session); 658 return connect(sock, (sockaddr*)&addr, sizeof(addr.sun_path)) != -1; 659 } 660 661 RemoteClient::RemoteClient(StringView session, StringView name, UniquePtr<UserInterface>&& ui, 662 int pid, const EnvVarMap& env_vars, StringView init_command, 663 Optional<BufferCoord> init_coord, Optional<int> stdin_fd) 664 : m_ui(std::move(ui)) 665 { 666 int sock = connect_to(session); 667 668 { 669 MsgWriter msg{m_send_buffer, MessageType::Connect}; 670 msg.write(pid, name, init_command, init_coord, m_ui->dimensions(), env_vars); 671 } 672 send_data(sock, m_send_buffer, stdin_fd); 673 674 m_ui->set_on_key([this](Key key){ 675 MsgWriter msg(m_send_buffer, MessageType::Key); 676 msg.write(key); 677 m_socket_watcher->events() |= FdEvents::Write; 678 }); 679 m_ui->set_on_paste([this](StringView content){ 680 MsgWriter msg(m_send_buffer, MessageType::Paste); 681 msg.write(content); 682 m_socket_watcher->events() |= FdEvents::Write; 683 }); 684 685 m_socket_watcher.reset(new FDWatcher{sock, FdEvents::Read | FdEvents::Write, EventMode::Urgent, 686 [this, reader = MsgReader{}](FDWatcher& watcher, FdEvents events, EventMode) mutable { 687 const int sock = watcher.fd(); 688 if (events & FdEvents::Write and send_data(sock, m_send_buffer)) 689 watcher.events() &= ~FdEvents::Write; 690 691 auto exec = [&]<typename ...Args>(void (UserInterface::*method)(Args...)) { 692 struct Impl // Use a constructor to ensure left-to-right parameter evaluation 693 { 694 Impl(UserInterface& ui, void (UserInterface::*method)(Args...), Args... args) 695 { 696 (ui.*method)(std::forward<Args>(args)...); 697 } 698 }; 699 Impl{*m_ui, method, reader.read<std::remove_cvref_t<Args>>()...}; 700 }; 701 702 while (events & FdEvents::Read and 703 not reader.ready() and fd_readable(sock)) 704 { 705 reader.read_available(sock); 706 707 if (not reader.ready()) 708 continue; 709 710 auto clear_reader = OnScopeEnd([&reader] { reader.reset(); }); 711 switch (reader.type()) 712 { 713 case MessageType::MenuShow: 714 exec(&UserInterface::menu_show); 715 break; 716 case MessageType::MenuSelect: 717 exec(&UserInterface::menu_select); 718 break; 719 case MessageType::MenuHide: 720 exec(&UserInterface::menu_hide); 721 break; 722 case MessageType::InfoShow: 723 exec(&UserInterface::info_show); 724 break; 725 case MessageType::InfoHide: 726 exec(&UserInterface::info_hide); 727 break; 728 case MessageType::Draw: 729 exec(&UserInterface::draw); 730 break; 731 case MessageType::DrawStatus: 732 exec(&UserInterface::draw_status); 733 break; 734 case MessageType::Refresh: 735 exec(&UserInterface::refresh); 736 break; 737 case MessageType::SetOptions: 738 exec(&UserInterface::set_ui_options); 739 break; 740 case MessageType::Exit: 741 m_exit_status = reader.read<int>(); 742 watcher.close_fd(); 743 return; 744 default: 745 kak_assert(false); 746 } 747 } 748 }}); 749 } 750 751 bool RemoteClient::is_ui_ok() const 752 { 753 return m_ui->is_ok(); 754 } 755 756 void send_command(StringView session, StringView command) 757 { 758 int sock = connect_to(session); 759 auto close_sock = OnScopeEnd([sock]{ close(sock); }); 760 RemoteBuffer buffer; 761 { 762 MsgWriter msg{buffer, MessageType::Command}; 763 msg.write(command); 764 } 765 write(sock, {buffer.data(), buffer.data() + buffer.size()}); 766 } 767 768 769 // A client accepter handle a connection until it closes or a nul byte is 770 // recieved. Everything recieved before is considered to be a command. 771 // 772 // * When a nul byte is recieved, the socket is handed to a new Client along 773 // with the command. 774 // * When the connection is closed, the command is run in an empty context. 775 class Server::Accepter 776 { 777 public: 778 Accepter(int socket) 779 : m_socket_watcher(socket, FdEvents::Read, EventMode::Normal, 780 [this](FDWatcher&, FdEvents, EventMode mode) { 781 handle_available_input(mode); 782 }) 783 {} 784 785 private: 786 void handle_available_input(EventMode mode) 787 { 788 const int sock = m_socket_watcher.fd(); 789 try 790 { 791 while (not m_reader.ready() and fd_readable(sock)) 792 m_reader.read_available(sock); 793 794 if (mode != EventMode::Normal or not m_reader.ready()) 795 return; 796 797 switch (m_reader.type()) 798 { 799 case MessageType::Connect: 800 { 801 auto pid = m_reader.read<int>(); 802 auto name = m_reader.read<String>(); 803 auto init_cmds = m_reader.read<String>(); 804 auto init_coord = m_reader.read<Optional<BufferCoord>>(); 805 auto dimensions = m_reader.read<DisplayCoord>(); 806 auto env_vars = m_reader.read<HashMap<String, String, MemoryDomain::EnvVars>>(); 807 808 if (auto stdin_fd = m_reader.ancillary_fd()) 809 create_fifo_buffer(generate_buffer_name("*stdin-{}*"), *stdin_fd, Buffer::Flags::None, 810 AutoScroll::NotInitially); 811 auto* ui = new RemoteUI{sock, dimensions}; 812 ClientManager::instance().create_client( 813 UniquePtr<UserInterface>(ui), pid, std::move(name), 814 std::move(env_vars), init_cmds, {}, init_coord, 815 [ui](int status) { ui->exit(status); }); 816 817 Server::instance().remove_accepter(this); 818 break; 819 } 820 case MessageType::Command: 821 { 822 auto command = m_reader.read<String>(); 823 if (not command.empty()) try 824 { 825 Context context{Context::EmptyContextFlag{}}; 826 CommandManager::instance().execute(command, context); 827 } 828 catch (const runtime_error& e) 829 { 830 write_to_debug_buffer(format("error running command '{}': {}", 831 command, e.what())); 832 } 833 close(sock); 834 Server::instance().remove_accepter(this); 835 break; 836 } 837 default: 838 write_to_debug_buffer("invalid introduction message received"); 839 close(sock); 840 Server::instance().remove_accepter(this); 841 } 842 } 843 catch (const disconnected& err) 844 { 845 write_to_debug_buffer(format("accepting connection failed: {}", err.what())); 846 close(sock); 847 Server::instance().remove_accepter(this); 848 } 849 } 850 851 FDWatcher m_socket_watcher; 852 MsgReader m_reader; 853 }; 854 855 Server::Server(String session_name, bool is_daemon) 856 : m_session{std::move(session_name)}, m_is_daemon{is_daemon} 857 { 858 int listen_sock = socket(AF_UNIX, SOCK_STREAM, 0); 859 fcntl(listen_sock, F_SETFD, FD_CLOEXEC); 860 sockaddr_un addr = session_addr(m_session); 861 862 make_directory(session_directory(), 0711); 863 864 // Do not give any access to the socket to other users by default 865 auto old_mask = umask(0077); 866 auto restore_mask = OnScopeEnd([old_mask]() { umask(old_mask); }); 867 868 if (bind(listen_sock, (sockaddr*) &addr, sizeof(sockaddr_un)) == -1) 869 throw runtime_error(format("unable to bind listen socket '{}': {}", 870 addr.sun_path, strerror(errno))); 871 872 if (listen(listen_sock, 4) == -1) 873 throw runtime_error(format("unable to listen on socket '{}': {}", 874 addr.sun_path, strerror(errno))); 875 876 auto accepter = [this](FDWatcher& watcher, FdEvents, EventMode) { 877 sockaddr_un client_addr; 878 socklen_t client_addr_len = sizeof(sockaddr_un); 879 int sock = accept(watcher.fd(), (sockaddr*) &client_addr, 880 &client_addr_len); 881 if (sock == -1) 882 throw runtime_error("accept failed"); 883 fcntl(sock, F_SETFD, FD_CLOEXEC); 884 885 m_accepters.emplace_back(new Accepter{sock}); 886 }; 887 m_listener.reset(new FDWatcher{listen_sock, FdEvents::Read, EventMode::Urgent, accepter}); 888 } 889 890 bool Server::rename_session(StringView name) 891 { 892 String old_socket_file = session_path(m_session, true); 893 String new_socket_file = session_path(name); 894 895 if (file_exists(new_socket_file)) 896 return false; 897 898 if (rename(old_socket_file.c_str(), new_socket_file.c_str()) != 0) 899 return false; 900 901 m_session = name.str(); 902 return true; 903 } 904 905 void Server::close_session(bool do_unlink) 906 { 907 if (do_unlink) 908 { 909 String socket_file = session_path(m_session, true); 910 unlink(socket_file.c_str()); 911 } 912 m_listener->close_fd(); 913 m_listener.reset(); 914 } 915 916 Server::~Server() 917 { 918 if (m_listener) 919 close_session(); 920 } 921 922 void Server::remove_accepter(Accepter* accepter) 923 { 924 auto it = find(m_accepters, accepter); 925 kak_assert(it != m_accepters.end()); 926 m_accepters.erase(it); 927 } 928 929 }