Improve clipboard robustness

[layercak3]

Some changes which improve our robustness with weird files or misbehaving clients.
I have read and understood CONTRIBUTING.md.

[any1]

LGTM.

How did you test this?

[layercak3]

How did you test this?

I used a small test client that sends a closed pipe (before patch, wayvnc gets SIGPIPE soon after the write call, but I guess has enough time to print that "write from clipboard incomplete" message), or does single a read() with a small buffer (before patch, wayvnc blocks on the write() call if its selection data is large)

client

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <wayland-client.h>
#include "wlr-data-control-unstable-v1-client-protocol.h"

static const char wayvnc_offer_prefix[] = "x-wayvnc-client-";

struct state {
        struct wl_display *display;
        struct wl_registry *registry;
        struct wl_seat *seat;
        struct zwlr_data_control_manager_v1 *data_control_manager;
        struct zwlr_data_control_device_v1 *data_control_device;
        struct zwlr_data_control_offer_v1 *current_offer;
};

static void bad_receive(struct state *state,
                struct zwlr_data_control_offer_v1 *offer)
{
        printf("Doing receive.\n");
        int pipe_fd[2];
        char *buf = malloc(8388608);
        ssize_t ret = 0;

        if (pipe(pipe_fd) == -1) {
                perror("pipe");
                return;
        }

        zwlr_data_control_offer_v1_receive(offer, "text/plain;charset=utf-8",
                        pipe_fd[1]);
        close(pipe_fd[1]);
//      close(pipe_fd[0]);

        wl_display_roundtrip(state->display);

/*      ret = read(pipe_fd[0], buf, 88);
        if (ret == -1) {
                perror("read");
                close(pipe_fd[0]);
        }*/

//      close(pipe_fd[0]);

        printf("Received bytes:\n%.*s\n", ret, buf);
}

static void handle_offer(void *data, struct zwlr_data_control_offer_v1 *offer,
                const char *mime_type)
{
        struct state *state = data;
        if (strncmp(wayvnc_offer_prefix, mime_type,
                                strlen(wayvnc_offer_prefix)) == 0)
                        state->current_offer = offer;
}

static const struct zwlr_data_control_offer_v1_listener data_control_offer_listener = {
        .offer = handle_offer,
};

static void handle_data_offer(void *data,
                struct zwlr_data_control_device_v1 *data_control_device,
                struct zwlr_data_control_offer_v1 *id)
{
        struct state *state = data;
        zwlr_data_control_offer_v1_add_listener(id, &data_control_offer_listener, data);
}

static void handle_selection(void *data,
                struct zwlr_data_control_device_v1 *data_control_device,
                struct zwlr_data_control_offer_v1 *id)
{
        struct state *state = data;

        if (!id) {
                if (state->current_offer) {
                        zwlr_data_control_offer_v1_destroy(state->current_offer);
                        state->current_offer = NULL;
                }
                return;
        }

        if (id == state->current_offer)
                bad_receive(state, id);

        zwlr_data_control_offer_v1_destroy(id);
        state->current_offer = NULL;
}

static void handle_finished(void *data,
                struct zwlr_data_control_device_v1 *zwlr_data_control_device_v1)
{
        struct state *state = data;
        zwlr_data_control_device_v1_destroy(zwlr_data_control_device_v1);
        if (state->data_control_device == zwlr_data_control_device_v1)
                state->data_control_device = NULL;
        if (state->current_offer) {
                zwlr_data_control_offer_v1_destroy(state->current_offer);
                state->current_offer = NULL;
        }
}

static void handle_primary_selection(void* data,
                struct zwlr_data_control_device_v1 *data_control_device,
                struct zwlr_data_control_offer_v1* id)
{
        struct state *state = data;

        if (!id) {
                if (state->current_offer) {
                        zwlr_data_control_offer_v1_destroy(state->current_offer);
                        state->current_offer = NULL;
                }
                return;
        }

        zwlr_data_control_offer_v1_destroy(id);
        state->current_offer = NULL;
}

static const struct zwlr_data_control_device_v1_listener data_control_device_listener = {
        .data_offer = handle_data_offer,
        .selection = handle_selection,
        .finished = handle_finished,
        .primary_selection = handle_primary_selection,
};

static void handle_global(void *data, struct wl_registry *registry,
                uint32_t name, const char *interface, uint32_t version)
{
        struct state *state = data;
        if (strcmp(interface, zwlr_data_control_manager_v1_interface.name) == 0) {
                state->data_control_manager = wl_registry_bind(registry, name,
                                &zwlr_data_control_manager_v1_interface, 2);
        } else if (strcmp(interface, wl_seat_interface.name) == 0) {
                state->seat = wl_registry_bind(registry, name,
                                &wl_seat_interface, 9);
        }
}

static void handle_global_remove(void *data, struct wl_registry *registry,
                uint32_t name)
{
}

static const struct wl_registry_listener registry_listener = {
        .global = handle_global,
        .global_remove = handle_global_remove,
};

int main()
{
        struct state state = {0};

        state.display = wl_display_connect(NULL);
        if (!state.display) {
                fprintf(stderr, "Failed to connect to the compositor.\n");
                return EXIT_FAILURE;
        }

        state.registry = wl_display_get_registry(state.display);
        wl_registry_add_listener(state.registry, &registry_listener, &state);

        wl_display_roundtrip(state.display);

        if (!state.data_control_manager) {
                fprintf(stderr, "This compositor doesn't support the wlr data control protocol.\n");
                return EXIT_FAILURE;
        }

        if (!state.seat) {
                fprintf(stderr, "The compositor didn't give us a seat.\n");
                return EXIT_FAILURE;
        }

        state.data_control_device = 
                zwlr_data_control_manager_v1_get_data_device(
                                state.data_control_manager, state.seat);
        zwlr_data_control_device_v1_add_listener(state.data_control_device,
                        &data_control_device_listener, &state);

        while (wl_display_dispatch(state.display) != -1) {}
}

For testing the patch I generated a large random text file and copied it on the client (to test the async send code): base64 /dev/urandom | head -c 8388607 > /tmp/data.txt; wl-copy < /tmp/data.txt
Launched tigervnc with -Log 'Viewport:stderr:100' -MaxCutText 8388608
Sometimes I have to hover over the window multiple times for tigervnc to actually send the large clipboard update. And often tigervnc will send a 0 byte clipboard update before sending the actual clipboard update. But these are just unrelated Xwayland issues.
Then when wayvnc became the selection owner I ran wl-paste on the server via ssh in a loop or launched a large number of background wl-paste jobs, and exited tigervnc (or terminated wl-paste) while the sends were taking place to test incomplete writes. (valgrind and writing megabytes of text to a terminal slows things down to make this easier)

One issue is that when running under valgrind and I run wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste & wl-paste (etc.) on the server via ssh while wayvnc is the selection owner with that large text, when I exit tigervnc while the sends are happening, the client is never unreffed/closed and the sends are never cancelled. After the sends finish the client is still never unreffed/closed. When not running in valgrind and I exit tigervnc these sends are always cancelled and the client closes properly.
Hmm, this isn't dependent on having a bunch of send contexts running. It happens sometimes when exiting tigervnc while a clipboard update is being transferred from the client to server. Anyway, this is likely caused by something somewhere else in the codebase or in neatvnc, maybe this.

[any1]

Excellent. Thanks!