HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/ptyfwd.c

48,331 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: d2d32008e92a8e9c0e27cc32cde7fdc9dd2e090b

Lines 1001–1330 of 1,330

                        r = fd_nonblock(STDOUT_FILENO, true);
                        if (r < 0)
                                return r;
 
                        f->output_fd = STDOUT_FILENO;
                } else
                        f->close_output_fd = true;
        }
 
        r = fd_nonblock(master, true);
        if (r < 0)
                return r;
 
        f->master = master;
 
        /* Disable color/window title setting unless we talk to a good TTY */
        if (!isatty_safe(f->output_fd) || get_color_mode() == COLOR_OFF)
                f->flags |= PTY_FORWARD_DUMB_TERMINAL;
 
        if (ioctl(f->output_fd, TIOCGWINSZ, &ws) < 0)
                /* If we can't get the resolution from the output fd, then use our internal, regular width/height,
                 * i.e. something derived from $COLUMNS and $LINES if set. */
                ws = (struct winsize) {
                        .ws_row = lines(),
                        .ws_col = columns(),
                };
 
        (void) ioctl(master, TIOCSWINSZ, &ws);
 
        if (!FLAGS_SET(flags, PTY_FORWARD_READ_ONLY)) {
                bool same;
 
                assert(f->input_fd >= 0);
 
                r = fd_inode_same(f->input_fd, f->output_fd);
                if (r < 0)
                        return r;
                same = r > 0;
 
                if (tcgetattr(f->input_fd, &f->saved_stdin_attr) >= 0) {
                        struct termios raw_stdin_attr;
 
                        f->saved_stdin = true;
 
                        raw_stdin_attr = f->saved_stdin_attr;
                        cfmakeraw(&raw_stdin_attr);
 
                        if (!same)
                                raw_stdin_attr.c_oflag = f->saved_stdin_attr.c_oflag;
 
                        (void) tcsetattr(f->input_fd, TCSANOW, &raw_stdin_attr);
                }
 
                if (!same && tcgetattr(f->output_fd, &f->saved_stdout_attr) >= 0) {
                        struct termios raw_stdout_attr;
 
                        f->saved_stdout = true;
 
                        raw_stdout_attr = f->saved_stdout_attr;
                        cfmakeraw(&raw_stdout_attr);
                        raw_stdout_attr.c_iflag = f->saved_stdout_attr.c_iflag;
                        raw_stdout_attr.c_lflag = f->saved_stdout_attr.c_lflag;
                        (void) tcsetattr(f->output_fd, TCSANOW, &raw_stdout_attr);
                }
 
                r = sd_event_add_io(f->event, &f->stdin_event_source, f->input_fd, EPOLLIN|EPOLLET, on_stdin_event, f);
                if (r < 0 && r != -EPERM)
                        return r;
 
                if (r >= 0)
                        (void) sd_event_source_set_description(f->stdin_event_source, "ptyfwd-stdin");
        }
 
        r = sd_event_add_io(f->event, &f->stdout_event_source, f->output_fd, EPOLLOUT|EPOLLET, on_stdout_event, f);
        if (r == -EPERM)
                /* stdout without epoll support. Likely redirected to regular file. */
                f->stdout_writable = true;
        else if (r < 0)
                return r;
        else
                (void) sd_event_source_set_description(f->stdout_event_source, "ptyfwd-stdout");
 
        r = sd_event_add_io(f->event, &f->master_event_source, master, EPOLLIN|EPOLLOUT|EPOLLET, on_master_event, f);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(f->master_event_source, "ptyfwd-master");
 
        r = sd_event_add_signal(f->event, &f->sigwinch_event_source, SIGWINCH|SD_EVENT_SIGNAL_PROCMASK, on_sigwinch_event, f);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(f->sigwinch_event_source, "ptyfwd-sigwinch");
 
        r = sd_event_add_exit(f->event, &f->exit_event_source, on_exit_event, f);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(f->exit_event_source, "ptyfwd-exit");
 
        *ret = TAKE_PTR(f);
 
        return 0;
}
 
PTYForward* pty_forward_free(PTYForward *f) {
        if (!f)
                return NULL;
 
        pty_forward_disconnect(f);
        free(f->background_color);
        free(f->title);
        free(f->title_prefix);
 
        return mfree(f);
}
 
int pty_forward_honor_vhangup(PTYForward *f) {
        assert(f);
 
        if ((f->flags & (PTY_FORWARD_IGNORE_VHANGUP | PTY_FORWARD_IGNORE_INITIAL_VHANGUP)) == 0)
                return 0; /* nothing changed. */
 
        f->flags &= ~(PTY_FORWARD_IGNORE_VHANGUP | PTY_FORWARD_IGNORE_INITIAL_VHANGUP);
 
        if (f->master_hangup)
                return 0;
 
        /* We shall now react to vhangup()s? Let's check if we might be in one. */
        return pty_forward_add_defer(f);
}
 
bool pty_forward_vhangup_honored(const PTYForward *f) {
        assert(f);
 
        if (FLAGS_SET(f->flags, PTY_FORWARD_IGNORE_VHANGUP))
                return false;
 
        if (FLAGS_SET(f->flags, PTY_FORWARD_IGNORE_INITIAL_VHANGUP) && !f->read_from_master)
                return false;
 
        return true;
}
 
void pty_forward_set_hangup_handler(PTYForward *f, PTYForwardHangupHandler cb, void *userdata) {
        assert(f);
 
        f->hangup_handler = cb;
        f->hangup_userdata = userdata;
}
 
void pty_forward_set_hotkey_handler(PTYForward *f, PTYForwardHotkeyHandler cb, void *userdata) {
        assert(f);
 
        f->hotkey_handler = cb;
        f->hotkey_userdata = userdata;
}
 
int pty_forward_drain(PTYForward *f) {
        assert(f);
 
        /* Starts draining the forwarder. This makes sure the handler function is called the next time the
         * number of unprocessed bytes hits zero. */
 
        f->drain = true;
        return pty_forward_add_defer(f);
}
 
int pty_forward_set_priority(PTYForward *f, int64_t priority) {
        int r;
 
        assert(f);
 
        if (f->stdin_event_source) {
                r = sd_event_source_set_priority(f->stdin_event_source, priority);
                if (r < 0)
                        return r;
        }
 
        if (f->stdout_event_source) {
                r = sd_event_source_set_priority(f->stdout_event_source, priority);
                if (r < 0)
                        return r;
        }
 
        r = sd_event_source_set_priority(f->master_event_source, priority);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_priority(f->sigwinch_event_source, priority);
        if (r < 0)
                return r;
 
        return 0;
}
 
int pty_forward_set_width_height(PTYForward *f, unsigned width, unsigned height) {
        struct winsize ws;
 
        assert(f);
 
        if (width == UINT_MAX && height == UINT_MAX)
                return 0; /* noop */
 
        if (width != UINT_MAX &&
            (width == 0 || width > USHRT_MAX))
                return -ERANGE;
 
        if (height != UINT_MAX &&
            (height == 0 || height > USHRT_MAX))
                return -ERANGE;
 
        if (width == UINT_MAX || height == UINT_MAX) {
                if (ioctl(f->master, TIOCGWINSZ, &ws) < 0)
                        return -errno;
 
                if (width != UINT_MAX)
                        ws.ws_col = width;
                if (height != UINT_MAX)
                        ws.ws_row = height;
        } else
                ws = (struct winsize) {
                        .ws_row = height,
                        .ws_col = width,
                };
 
        if (ioctl(f->master, TIOCSWINSZ, &ws) < 0)
                return -errno;
 
        /* Make sure we ignore SIGWINCH window size events from now on */
        f->sigwinch_event_source = sd_event_source_unref(f->sigwinch_event_source);
 
        return 0;
}
 
int pty_forward_set_background_color(PTYForward *f, const char *color) {
        assert(f);
 
        return free_and_strdup(&f->background_color, color);
}
 
int pty_forward_set_title(PTYForward *f, const char *title) {
        assert(f);
 
        /* Refuse accepting a title when we already started shoveling */
        if (f->out_buffer_size > 0)
                return -EBUSY;
 
        if (!title) {
                f->title = mfree(f->title);
                return 0;
        }
 
        /* Truncate the title to 128 chars, since some terminal emulators really don't like overly long ANSI
         * sequences */
        _cleanup_free_ char *ellipsized = ellipsize(title, ANSI_SEQUENCE_WINDOW_TITLE_MAX, 66);
        if (!ellipsized)
                return -ENOMEM;
 
        return free_and_replace(f->title, ellipsized);
}
 
int pty_forward_set_titlef(PTYForward *f, const char *format, ...) {
        _cleanup_free_ char *title = NULL;
        va_list ap;
        int r;
 
        assert(f);
        assert(format);
 
        if (f->out_buffer_size > 0)
                return -EBUSY;
 
        va_start(ap, format);
        r = vasprintf(&title, format, ap);
        va_end(ap);
        if (r < 0)
                return -ENOMEM;
 
        return pty_forward_set_title(f, title);
}
 
int pty_forward_set_title_prefix(PTYForward *f, const char *title_prefix) {
        assert(f);
 
        return free_and_strdup(&f->title_prefix, title_prefix);
}
 
int pty_forward_set_window_title(
                PTYForward *f,
                Glyph circle,           /* e.g. GLYPH_GREEN_CIRCLE */
                const char *hostname,   /* Can be NULL, and obtained by gethostname_strict() in that case. */
                char * const *msg) {
 
        _cleanup_free_ char *hn = NULL, *dot = NULL, *joined = NULL;
        int r;
 
        assert(f);
 
        if (!shall_set_terminal_title())
                return 0;
 
        if (!hostname) {
                (void) gethostname_strict(&hn);
                hostname = hn;
        }
 
        if (circle >= 0 && emoji_enabled()) {
                dot = strjoin(glyph(circle), " ");
                if (!dot)
                        return -ENOMEM;
        }
 
        joined = strv_join(msg, " ");
        if (!joined)
                return -ENOMEM;
 
        r = pty_forward_set_titlef(f, "%s%s%s%s", strempty(dot), joined, hostname ? " on " : "", strempty(hostname));
        if (r < 0)
                return r;
 
        if (dot) {
                r = pty_forward_set_title_prefix(f, dot);
                if (r < 0)
                        return r;
        }
 
        return 0;
}