kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

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 }