cdkselection-wayland.c

Bug Summary

File:	cdk/wayland/cdkselection-wayland.c
Warning:	line 1488, column 19 Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cdkselection-wayland.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/cdk/wayland -fcoverage-compilation-dir=/rootdir/cdk/wayland -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I ../.. -D G_LOG_DOMAIN="Cdk" -D G_LOG_USE_STRUCTURED=1 -D CDK_COMPILATION -I ../.. -I ../../cdk -I ../../cdk -D G_ENABLE_DEBUG -D G_ENABLE_CONSISTENCY_CHECKS -D GLIB_MIN_REQUIRED_VERSION=GLIB_VERSION_2_66 -D GLIB_MAX_ALLOWED_VERSION=GLIB_VERSION_2_66 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-12-18-092428-43636-1 -x c cdkselection-wayland.c
1/*
* Copyright © 2010 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

18#include "config.h"

20#include <fcntl.h>
21#include <unistd.h>

23#include <gio/gunixinputstream.h>
24#include <gio/gunixoutputstream.h>
25#include <glib-unix1.h>

27#include "cdkwayland.h"
28#include "cdkprivate-wayland.h"
29#include "cdkdisplay-wayland.h"
30#include "cdkdndprivate.h"
31#include "cdkselection.h"
32#include "cdkproperty.h"
33#include "cdkprivate.h"

35#include <string.h>

37typedef struct _SelectionBuffer SelectionBuffer;
38typedef struct _SelectionData SelectionData;
39typedef struct _StoredSelection StoredSelection;
40typedef struct _AsyncWriteData AsyncWriteData;
41typedef struct _DataOfferData DataOfferData;

43struct _SelectionBuffer
44{
GInputStream *stream;
GCancellable *cancellable;
GByteArray *data;
GList *requestors;
CdkAtom selection;
CdkAtom target;
gint ref_count;
52};

54struct _StoredSelection
55{
CdkWaylandSelection *selection;
CdkWindow *source;
GCancellable *cancellable;
guchar *data;
gsize data_len;
CdkAtom type;
CdkAtom selection_atom;
GPtrArray *pending_writes; /* Array of AsyncWriteData */
64};

66struct _DataOfferData
67{
GDestroyNotify destroy_notify;
gpointer offer_data;
GList *targets; /* List of CdkAtom */
71};

73struct _AsyncWriteData
74{
GOutputStream *stream;
StoredSelection *stored_selection;
gsize index;
78};

80struct _SelectionData
81{
DataOfferData *offer;
GHashTable *buffers; /* Hashtable of target_atom->SelectionBuffer */
84};

86enum {
ATOM_PRIMARY,
ATOM_CLIPBOARD,
ATOM_DND,
N_ATOMS
91};

93static CdkAtom atoms[N_ATOMS] = { 0 };

95struct _CdkWaylandSelection
96{
/* Destination-side data */
SelectionData selections[N_ATOMS];
GHashTable *offers; /* Currently alive offers, Hashtable of wl_data_offer->DataOfferData */

/* Source-side data */
GPtrArray *stored_selections; /* Array of StoredSelection */
StoredSelection *current_request_selection;
GArray *source_targets;
CdkAtom requested_target;

gpointer primary_source;
CdkWindow *primary_owner;

struct wl_data_source *clipboard_source;
CdkWindow *clipboard_owner;

struct wl_data_source *dnd_source; /* Owned by the CdkDragContext */
CdkWindow *dnd_owner;
115};

117static void selection_buffer_read (SelectionBuffer *buffer);
118static void async_write_data_write (AsyncWriteData *write_data);
119static void async_write_data_free (AsyncWriteData *write_data);
120static void emit_selection_clear (CdkDisplay *display, CdkAtom selection);
121static void emit_empty_selection_notify (CdkWindow *requestor,
                                       CdkAtom    selection,
                                       CdkAtom    target);
124static void cdk_wayland_selection_handle_next_request (CdkWaylandSelection *wayland_selection);

126static void
127selection_buffer_notify (SelectionBuffer *buffer)
128{
GList *l;

for (l = buffer->requestors; l; l = l->next)
  {
    CdkEvent *event;

    event = cdk_event_new (CDK_SELECTION_NOTIFY);
    event->selection.window = g_object_ref (l->data)((__typeof__ (l->data)) (g_object_ref) (l->data));
    event->selection.send_event = FALSE(0);
    event->selection.selection = buffer->selection;
    event->selection.target = buffer->target;
    event->selection.property = cdk_atom_intern_static_string ("CDK_SELECTION");
    event->selection.time = CDK_CURRENT_TIME0L;
    event->selection.requestor = g_object_ref (l->data)((__typeof__ (l->data)) (g_object_ref) (l->data));

    cdk_event_put (event);
    cdk_event_free (event);
  }
147}

149static SelectionBuffer *
150selection_buffer_new (GInputStream *stream,
                    CdkAtom       selection,
                    CdkAtom       target)
153{
SelectionBuffer *buffer;

buffer = g_new0 (SelectionBuffer, 1)((SelectionBuffer *) g_malloc0_n ((1), sizeof (SelectionBuffer
)));
buffer->stream = (stream) ? g_object_ref (stream)((__typeof__ (stream)) (g_object_ref) (stream)) : NULL((void*)0);
buffer->cancellable = g_cancellable_new ();
buffer->data = g_byte_array_new ();
buffer->selection = selection;
buffer->target = target;
buffer->ref_count = 1;

if (stream)
  selection_buffer_read (buffer);

return buffer;
168}

170static SelectionBuffer *
171selection_buffer_ref (SelectionBuffer *buffer)
172{
buffer->ref_count++;
return buffer;
175}

177static void
178selection_buffer_unref (SelectionBuffer *buffer_data)
179{
GList *l;

buffer_data->ref_count--;

if (buffer_data->ref_count != 0)
  return;

for (l = buffer_data->requestors; l; l = l->next)
  {
    emit_empty_selection_notify (l->data, buffer_data->selection,
                                 buffer_data->target);
  }

g_list_free (buffer_data->requestors);
buffer_data->requestors = NULL((void*)0);

if (buffer_data->cancellable)
  g_object_unref (buffer_data->cancellable);

if (buffer_data->stream)
  g_object_unref (buffer_data->stream);

if (buffer_data->data)
  g_byte_array_unref (buffer_data->data);

g_free (buffer_data);
206}

208static void
209selection_buffer_append_data (SelectionBuffer *buffer,
                            gconstpointer    data,
                            gsize            len)
212{
g_byte_array_append (buffer->data, data, len);
214}

216static void
217selection_buffer_cancel_and_unref (SelectionBuffer *buffer_data)
218{
if (buffer_data->cancellable)
  g_cancellable_cancel (buffer_data->cancellable);

selection_buffer_unref (buffer_data);
223}

225static void
226selection_buffer_add_requestor (SelectionBuffer *buffer,
                              CdkWindow       *requestor)
228{
if (!g_list_find (buffer->requestors, requestor))
  buffer->requestors = g_list_prepend (buffer->requestors,
                                       g_object_ref (requestor)((__typeof__ (requestor)) (g_object_ref) (requestor)));
232}

234static gboolean
235selection_buffer_remove_requestor (SelectionBuffer *buffer,
                                 CdkWindow       *requestor)
237{
GList *link = g_list_find (buffer->requestors, requestor);

if (!link)
  return FALSE(0);

g_object_unref (link->data);
buffer->requestors = g_list_delete_link (buffer->requestors, link);
return TRUE(!(0));
246}

248static inline glong
249get_buffer_size (void)
250{
return sysconf (_SC_PAGESIZE_SC_PAGESIZE);
252}

254static void
255selection_buffer_read_cb (GObject      *object G_GNUC_UNUSED__attribute__ ((__unused__)),
                        GAsyncResult *result,
                        gpointer      user_data)
258{
SelectionBuffer *buffer = user_data;
gboolean finished = TRUE(!(0));
GError *error = NULL((void*)0);
GBytes *bytes;

bytes = g_input_stream_read_bytes_finish (buffer->stream, result, &error);

if (bytes)
  {
    finished = g_bytes_get_size (bytes) == 0;
    selection_buffer_append_data (buffer,
                                  g_bytes_get_data (bytes, NULL((void*)0)),
                                  g_bytes_get_size (bytes));
    g_bytes_unref (bytes);
  }

if (!finished)
  selection_buffer_read (buffer);
else
  {
    if (error)
      {
        g_warning (G_STRLOC"cdkselection-wayland.c" ":" "281" ": error reading selection buffer: %s", error->message);
        g_error_free (error);
      }
    else
      selection_buffer_notify (buffer);

    g_input_stream_close (buffer->stream, NULL((void*)0), NULL((void*)0));
    g_clear_object (&buffer->stream)do { _Static_assert (sizeof *((&buffer->stream)) == sizeof
 (gpointer), "Expression evaluates to false"); __typeof__ (((
&buffer->stream))) _pp = ((&buffer->stream)); __typeof__
 (*((&buffer->stream))) _ptr = *_pp; *_pp = ((void*)0)
; if (_ptr) (g_object_unref) (_ptr); } while (0);
    g_clear_object (&buffer->cancellable)do { _Static_assert (sizeof *((&buffer->cancellable)) ==
 sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&buffer->cancellable))) _pp = ((&buffer->cancellable
)); __typeof__ (*((&buffer->cancellable))) _ptr = *_pp
; *_pp = ((void*)0); if (_ptr) (g_object_unref) (_ptr); } while
 (0);
  }

selection_buffer_unref (buffer);
293}

295static void
296selection_buffer_read (SelectionBuffer *buffer)
297{
selection_buffer_ref (buffer);
g_input_stream_read_bytes_async (buffer->stream, get_buffer_size(),
                                 G_PRIORITY_DEFAULT0,
                                 buffer->cancellable, selection_buffer_read_cb,
                                 buffer);
303}

305static DataOfferData *
306data_offer_data_new (gpointer       offer,
                   GDestroyNotify destroy_notify)
308{
DataOfferData *info;

info = g_slice_new0 (DataOfferData)((DataOfferData*) g_slice_alloc0 (sizeof (DataOfferData)));
info->offer_data = offer;
info->destroy_notify = destroy_notify;

return info;
316}

318static void
319data_offer_data_free (DataOfferData *info)
320{
info->destroy_notify (info->offer_data);
g_list_free (info->targets);
g_slice_free (DataOfferData, info)do { if (1) g_slice_free1 (sizeof (DataOfferData), (info)); else
 (void) ((DataOfferData*) 0 == (info)); } while (0);
324}

326static StoredSelection *
327stored_selection_new (CdkWaylandSelection *wayland_selection,
                    CdkWindow           *source,
                    CdkAtom              selection,
                    CdkAtom              type)
331{
StoredSelection *stored_selection;

stored_selection = g_new0 (StoredSelection, 1)((StoredSelection *) g_malloc0_n ((1), sizeof (StoredSelection
)));
stored_selection->source = source;
stored_selection->type = type;
stored_selection->selection_atom = selection;
stored_selection->selection = wayland_selection;
stored_selection->cancellable = g_cancellable_new ();
stored_selection->pending_writes =
  g_ptr_array_new_with_free_func ((GDestroyNotify) async_write_data_free);

return stored_selection;
344}

346static void
347stored_selection_add_data (StoredSelection *stored_selection,
                         CdkPropMode      mode,
                         guchar          *data,
                         gsize            data_len)
351{
if (mode == CDK_PROP_MODE_REPLACE)
  {
    g_free (stored_selection->data);
    stored_selection->data = g_memdup2 (data, data_len);
    stored_selection->data_len = data_len;
  }
else
  {
    GArray *array;

    array = g_array_new (TRUE(!(0)), TRUE(!(0)), sizeof (guchar));
    g_array_append_vals (array, stored_selection->data, stored_selection->data_len);

    if (mode == CDK_PROP_MODE_APPEND)
      g_array_append_vals (array, data, data_len);
    else if (mode == CDK_PROP_MODE_PREPEND)
      g_array_prepend_vals (array, data, data_len);

    g_free (stored_selection->data);
    stored_selection->data_len = array->len;
    stored_selection->data = (guchar *) g_array_free (array, FALSE(0));
  }
374}

376static void
377stored_selection_free (StoredSelection *stored_selection)
378{
g_cancellable_cancel (stored_selection->cancellable);
g_object_unref (stored_selection->cancellable);
g_ptr_array_unref (stored_selection->pending_writes);
g_free (stored_selection->data);
g_free (stored_selection);
384}

386static void
387stored_selection_notify_write (StoredSelection *stored_selection)
388{
gint i;

for (i = 0; i < stored_selection->pending_writes->len; i++)
  {
    AsyncWriteData *write_data;

    write_data = g_ptr_array_index (stored_selection->pending_writes, i)((stored_selection->pending_writes)->pdata)[i];
    async_write_data_write (write_data);
  }
398}

400static void
401stored_selection_cancel_write (StoredSelection *stored_selection)
402{
g_cancellable_cancel (stored_selection->cancellable);
g_object_unref (stored_selection->cancellable);
stored_selection->cancellable = g_cancellable_new ();
g_ptr_array_set_size (stored_selection->pending_writes, 0);
407}

409CdkWaylandSelection *
410cdk_wayland_selection_new (void)
411{
CdkWaylandSelection *selection;
gint i;

/* init atoms */
atoms[ATOM_PRIMARY] = cdk_atom_intern_static_string ("PRIMARY");
atoms[ATOM_CLIPBOARD] = cdk_atom_intern_static_string ("CLIPBOARD");
atoms[ATOM_DND] = cdk_atom_intern_static_string ("CdkWaylandSelection");

selection = g_new0 (CdkWaylandSelection, 1)((CdkWaylandSelection *) g_malloc0_n ((1), sizeof (CdkWaylandSelection
)));
for (i = 0; i < G_N_ELEMENTS (selection->selections)(sizeof (selection->selections) / sizeof ((selection->selections
)[0])); i++)
  {
    selection->selections[i].buffers =
      g_hash_table_new_full (NULL((void*)0), NULL((void*)0), NULL((void*)0),
                             (GDestroyNotify) selection_buffer_cancel_and_unref);
  }

selection->offers =
  g_hash_table_new_full (NULL((void*)0), NULL((void*)0), NULL((void*)0),
                         (GDestroyNotify) data_offer_data_free);
selection->stored_selections =
  g_ptr_array_new_with_free_func ((GDestroyNotify) stored_selection_free);

selection->source_targets = g_array_new (FALSE(0), FALSE(0), sizeof (CdkAtom));
return selection;
436}

438static void
439primary_selection_source_destroy (gpointer primary_source)
440{
CdkDisplay *display = cdk_display_get_default ();
CdkWaylandDisplay *display_wayland = CDK_WAYLAND_DISPLAY (display)((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((display)), ((cdk_wayland_display_get_type(
)))))));

if (display_wayland->zwp_primary_selection_manager_v1)
  zwp_primary_selection_source_v1_destroy (primary_source);
else if (display_wayland->ctk_primary_selection_manager)
  ctk_primary_selection_source_destroy (primary_source);
448}

450void
451cdk_wayland_selection_free (CdkWaylandSelection *selection)
452{
gint i;

for (i = 0; i < G_N_ELEMENTS (selection->selections)(sizeof (selection->selections) / sizeof ((selection->selections
)[0])); i++)
  g_hash_table_destroy (selection->selections[i].buffers);

g_array_unref (selection->source_targets);

g_hash_table_destroy (selection->offers);
g_ptr_array_unref (selection->stored_selections);

if (selection->primary_source)
  primary_selection_source_destroy (selection->primary_source);
if (selection->clipboard_source)
  wl_data_source_destroy (selection->clipboard_source);
if (selection->dnd_source)
  wl_data_source_destroy (selection->dnd_source);

g_free (selection);
471}

473static void
474data_offer_offer (void                 *data,
                struct wl_data_offer *wl_data_offer,
                const char           *type)
477{
CdkWaylandSelection *selection = data;
DataOfferData *info;
CdkAtom atom = cdk_atom_intern (type, FALSE(0));

info = g_hash_table_lookup (selection->offers, wl_data_offer);

if (!info || g_list_find (info->targets, atom))
  return;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data offer offer, offer %p, type = %s", wl_data_offer, type
); }; } while (0)
          g_message ("data offer offer, offer %p, type = %s", wl_data_offer, type))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data offer offer, offer %p, type = %s", wl_data_offer, type
); }; } while (0);

info->targets = g_list_prepend (info->targets, atom);
491}

493static inline CdkDragAction
494_wl_to_cdk_actions (uint32_t dnd_actions)
495{
CdkDragAction actions = 0;

if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
  actions |= CDK_ACTION_COPY;
if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
  actions |= CDK_ACTION_MOVE;
if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
  actions |= CDK_ACTION_ASK;

return actions;
506}

508static void
509data_offer_source_actions (void                 *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                         struct wl_data_offer *wl_data_offer,
                         uint32_t              source_actions)
512{
CdkDragContext *drop_context;
CdkDisplay *display;
CdkDevice *device;
CdkSeat *seat;

display = cdk_display_get_default ();
seat = cdk_display_get_default_seat (display);
device = cdk_seat_get_pointer (seat);
drop_context = cdk_wayland_device_get_drop_context (device);

drop_context->actions = _wl_to_cdk_actions (source_actions);

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data offer source actions, offer %p, actions %d", wl_data_offer
, source_actions); }; } while (0)
          g_message ("data offer source actions, offer %p, actions %d", wl_data_offer, source_actions))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data offer source actions, offer %p, actions %d", wl_data_offer
, source_actions); }; } while (0);

if (cdk_drag_context_get_dest_window (drop_context))
  _cdk_wayland_drag_context_emit_event (drop_context, CDK_DRAG_MOTION,
                                        CDK_CURRENT_TIME0L);
531}

533static void
534data_offer_action (void                 *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                 struct wl_data_offer *wl_data_offer G_GNUC_UNUSED__attribute__ ((__unused__)),
                 uint32_t              action)
537{
CdkDragContext *drop_context;
CdkDisplay *display;
CdkDevice *device;
CdkSeat *seat;

display = cdk_display_get_default ();
seat = cdk_display_get_default_seat (display);
device = cdk_seat_get_pointer (seat);
drop_context = cdk_wayland_device_get_drop_context (device);

drop_context->action = _wl_to_cdk_actions (action);

if (cdk_drag_context_get_dest_window (drop_context))
  _cdk_wayland_drag_context_emit_event (drop_context, CDK_DRAG_MOTION,
                                        CDK_CURRENT_TIME0L);
553}

555static const struct wl_data_offer_listener data_offer_listener = {
data_offer_offer,
data_offer_source_actions,
data_offer_action
559};

561static void
562primary_offer_offer (void       *data,
                   gpointer    offer,
                   const char *type)
565{
CdkWaylandSelection *selection = data;
DataOfferData *info;
CdkAtom atom = cdk_atom_intern (type, FALSE(0));

info = g_hash_table_lookup (selection->offers, offer);

if (!info || g_list_find (info->targets, atom))
  return;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary offer offer, offer %p, type = %s", offer, type); }
; } while (0)
          g_message ("primary offer offer, offer %p, type = %s", offer, type))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary offer offer, offer %p, type = %s", offer, type); }
; } while (0);

info->targets = g_list_prepend (info->targets, atom);
579}

581static void
582ctk_primary_offer_offer (void                               *data,
                       struct ctk_primary_selection_offer *offer,
                       const char                         *type)
585{
primary_offer_offer (data, (gpointer) offer, type);
587}

589static void
590zwp_primary_offer_v1_offer (void                                  *data,
                          struct zwp_primary_selection_offer_v1 *offer,
                          const char                            *type)
593{
primary_offer_offer (data, (gpointer) offer, type);
595}

597static const struct ctk_primary_selection_offer_listener ctk_primary_offer_listener = {
ctk_primary_offer_offer,
599};

601static const struct zwp_primary_selection_offer_v1_listener zwp_primary_offer_listener_v1 = {
zwp_primary_offer_v1_offer,
603};

605SelectionData *
606selection_lookup_offer_by_atom (CdkWaylandSelection *selection,
                              CdkAtom              selection_atom)
608{
if (selection_atom == atoms[ATOM_PRIMARY])
  return &selection->selections[ATOM_PRIMARY];
else if (selection_atom == atoms[ATOM_CLIPBOARD])
  return &selection->selections[ATOM_CLIPBOARD];
else if (selection_atom == atoms[ATOM_DND])
  return &selection->selections[ATOM_DND];
else
  return NULL((void*)0);
617}

619void
620cdk_wayland_selection_ensure_offer (CdkDisplay           *display,
                                  struct wl_data_offer *wl_offer)
622{
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
DataOfferData *info;

info = g_hash_table_lookup (selection->offers, wl_offer);

if (!info)
  {
    info = data_offer_data_new (wl_offer,
                                (GDestroyNotify) wl_data_offer_destroy);
    g_hash_table_insert (selection->offers, wl_offer, info);
    wl_data_offer_add_listener (wl_offer,
                                &data_offer_listener,
                                selection);
  }
637}

639void
640cdk_wayland_selection_ensure_primary_offer (CdkDisplay *display,
                                          gpointer    ctk_offer)
642{
CdkWaylandDisplay *display_wayland = CDK_WAYLAND_DISPLAY (display)((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((display)), ((cdk_wayland_display_get_type(
)))))));
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
DataOfferData *info;

info = g_hash_table_lookup (selection->offers, ctk_offer);

if (!info)
  {
    if (display_wayland->zwp_primary_selection_manager_v1)
      {
        info = data_offer_data_new (ctk_offer,
                                    (GDestroyNotify) zwp_primary_selection_offer_v1_destroy);
        g_hash_table_insert (selection->offers, ctk_offer, info);
        zwp_primary_selection_offer_v1_add_listener (ctk_offer,
                                                     &zwp_primary_offer_listener_v1,
                                                     selection);
      }
    else if (display_wayland->ctk_primary_selection_manager)
      {
        info = data_offer_data_new (ctk_offer,
                                    (GDestroyNotify) ctk_primary_selection_offer_destroy);
        g_hash_table_insert (selection->offers, ctk_offer, info);
        ctk_primary_selection_offer_add_listener (ctk_offer,
                                                  &ctk_primary_offer_listener,
                                                  selection);
      }
  }
670}

672void
673cdk_wayland_selection_set_offer (CdkDisplay *display,
                               CdkAtom     selection_atom,
                               gpointer    wl_offer)
676{
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
struct wl_data_offer *prev_offer;
SelectionData *selection_data;
DataOfferData *info;

info = g_hash_table_lookup (selection->offers, wl_offer);

prev_offer = cdk_wayland_selection_get_offer (display, selection_atom);

if (prev_offer)
  g_hash_table_remove (selection->offers, prev_offer);

selection_data = selection_lookup_offer_by_atom (selection, selection_atom);

if (selection_data)
  {
    selection_data->offer = info;
    /* Clear all buffers */
    g_hash_table_remove_all (selection_data->buffers);
  }
697}

699gpointer
700cdk_wayland_selection_get_offer (CdkDisplay *display,
                               CdkAtom     selection_atom)
702{
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
const SelectionData *data;

data = selection_lookup_offer_by_atom (selection, selection_atom);

if (data && data->offer)
  return data->offer->offer_data;

return NULL((void*)0);
712}

714GList *
715cdk_wayland_selection_get_targets (CdkDisplay *display,
                                 CdkAtom     selection_atom)
717{
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
const SelectionData *data;

data = selection_lookup_offer_by_atom (selection, selection_atom);

if (data && data->offer)
  return data->offer->targets;

return NULL((void*)0);
727}

729static void
730cdk_wayland_selection_emit_request (CdkWindow *window,
                                  CdkAtom    selection,
                                  CdkAtom    target)
733{
CdkEvent *event;

event = cdk_event_new (CDK_SELECTION_REQUEST);
event->selection.window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
event->selection.send_event = FALSE(0);
event->selection.selection = selection;
event->selection.target = target;
event->selection.property = cdk_atom_intern_static_string ("CDK_SELECTION");
event->selection.time = CDK_CURRENT_TIME0L;
event->selection.requestor = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

cdk_event_put (event);
cdk_event_free (event);
747}

749static AsyncWriteData *
750async_write_data_new (StoredSelection *stored_selection,
                    gint             fd)
752{
AsyncWriteData *write_data;

write_data = g_slice_new0 (AsyncWriteData)((AsyncWriteData*) g_slice_alloc0 (sizeof (AsyncWriteData)));
write_data->stored_selection = stored_selection;
write_data->stream = g_unix_output_stream_new (fd, TRUE(!(0)));
g_ptr_array_add (stored_selection->pending_writes, write_data);

return write_data;
761}

763static void
764async_write_data_free (AsyncWriteData *write_data)
765{
g_object_unref (write_data->stream);
g_slice_free (AsyncWriteData, write_data)do { if (1) g_slice_free1 (sizeof (AsyncWriteData), (write_data
)); else (void) ((AsyncWriteData*) 0 == (write_data)); } while
 (0);
768}

770static void
771async_write_data_cb (GObject      *object,
                   GAsyncResult *res,
                   gpointer      user_data)
774{
AsyncWriteData *write_data = user_data;
GError *error = NULL((void*)0);
gsize bytes_written;

bytes_written = g_output_stream_write_finish (G_OUTPUT_STREAM (object)((((GOutputStream*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((g_output_stream_get_type ())))))),
                                              res, &error);
if (error)
  {
    if (!g_error_matches (error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_CANCELLED))
      {
        g_warning ("Error writing selection data: %s", error->message);
        g_ptr_array_remove_fast (write_data->stored_selection->pending_writes,
                                 write_data);
      }

    g_error_free (error);
    return;
  }

write_data->index += bytes_written;

if (write_data->index < write_data->stored_selection->data_len)
  {
    /* Write the next chunk */
    async_write_data_write (write_data);
  }
else
  {
    g_ptr_array_remove_fast (write_data->stored_selection->pending_writes,
                             write_data);
  }
806}

808static void
809async_write_data_write (AsyncWriteData *write_data)
810{
gsize buf_len;
guchar *buf;

buf = write_data->stored_selection->data;
buf_len = write_data->stored_selection->data_len;

g_output_stream_write_async (write_data->stream,
                             &buf[write_data->index],
                             buf_len - write_data->index,
                             G_PRIORITY_DEFAULT0,
                             write_data->stored_selection->cancellable,
                             async_write_data_cb,
                             write_data);
824}

826static StoredSelection *
827cdk_wayland_selection_find_stored_selection (CdkWaylandSelection *wayland_selection,
                                           CdkWindow           *window,
                                           CdkAtom              selection,
                                           CdkAtom              type)
831{
gint i;

for (i = 0; i < wayland_selection->stored_selections->len; i++)
  {
    StoredSelection *stored_selection;

    stored_selection = g_ptr_array_index (wayland_selection->stored_selections, i)((wayland_selection->stored_selections)->pdata)[i];

    if (stored_selection->source == window &&
        stored_selection->selection_atom == selection &&
        stored_selection->type == type)
      return stored_selection;
  }

return NULL((void*)0);
847}

849static void
850cdk_wayland_selection_reset_selection (CdkWaylandSelection *wayland_selection,
                                     CdkAtom              selection)
852{
gint i = 0;

while (i < wayland_selection->stored_selections->len)
  {
    StoredSelection *stored_selection;

    stored_selection = g_ptr_array_index (wayland_selection->stored_selections, i)((wayland_selection->stored_selections)->pdata)[i];

    if (stored_selection->selection_atom == selection)
      {
        if (wayland_selection->current_request_selection == stored_selection)
          wayland_selection->current_request_selection = NULL((void*)0);

        g_ptr_array_remove_index_fast (wayland_selection->stored_selections, i);
      }
    else
      i++;
  }
871}

873void
874cdk_wayland_selection_store (CdkWindow    *window,
                           CdkAtom       type,
                           CdkPropMode   mode,
                           const guchar *data,
                           gint          len)
879{
CdkDisplay *display = cdk_window_get_display (window);
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
StoredSelection *stored_selection;

if (type == cdk_atom_intern_static_string ("NULL"))
  return;
if (!selection->current_request_selection)
  return;

stored_selection = selection->current_request_selection;

if ((mode == CDK_PROP_MODE_PREPEND ||
     mode == CDK_PROP_MODE_REPLACE) &&
    stored_selection->data &&
    stored_selection->pending_writes->len > 0)
  {
    /* If a prepend/replace action happens, all current readers are
     * pretty much stale.
     */
    stored_selection_cancel_write (stored_selection);
  }

stored_selection_add_data (stored_selection, mode, data, len);

if (stored_selection->data)
  stored_selection_notify_write (stored_selection);
else
  {
    g_ptr_array_remove_fast (selection->stored_selections,
                             stored_selection);
  }

/* Handle the next CDK_SELECTION_REQUEST / store, if any */
selection->current_request_selection = NULL((void*)0);
cdk_wayland_selection_handle_next_request (selection);
915}

917static SelectionBuffer *
918cdk_wayland_selection_lookup_requestor_buffer (CdkWindow *requestor)
919{
CdkDisplay *display = cdk_window_get_display (requestor);
CdkWaylandSelection *selection = cdk_wayland_display_get_selection (display);
SelectionBuffer *buffer_data;
GHashTableIter iter;
gint i;

for (i = 0; i < G_N_ELEMENTS (selection->selections)(sizeof (selection->selections) / sizeof ((selection->selections
)[0])); i++)
  {
    g_hash_table_iter_init (&iter, selection->selections[i].buffers);

    while (g_hash_table_iter_next (&iter, NULL((void*)0), (gpointer*) &buffer_data))
      {
        if (g_list_find (buffer_data->requestors, requestor))
          return buffer_data;
      }
  }

return NULL((void*)0);
938}

940static gboolean
941cdk_wayland_selection_source_handles_target (CdkWaylandSelection *wayland_selection,
                                           CdkAtom              target)
943{
CdkAtom atom;
guint i;

if (target == CDK_NONE((CdkAtom)((gpointer) (gulong) (0))))
  return FALSE(0);

for (i = 0; i < wayland_selection->source_targets->len; i++)
  {
    atom = g_array_index (wayland_selection->source_targets, CdkAtom, i)(((CdkAtom*) (void *) (wayland_selection->source_targets)->
data) [(i)]);

    if (atom == target)
      return TRUE(!(0));
  }

return FALSE(0);
959}

961static void
962cdk_wayland_selection_handle_next_request (CdkWaylandSelection *wayland_selection)
963{
gint i;

for (i = 0; i < wayland_selection->stored_selections->len; i++)
  {
    StoredSelection *stored_selection;

    stored_selection = g_ptr_array_index (wayland_selection->stored_selections, i)((wayland_selection->stored_selections)->pdata)[i];

    if (!stored_selection->data)
      {
        cdk_wayland_selection_emit_request (stored_selection->source,
                                            stored_selection->selection_atom,
                                            stored_selection->type);
        wayland_selection->current_request_selection = stored_selection;
        break;
      }
  }
981}

983static gboolean
984cdk_wayland_selection_request_target (CdkWaylandSelection *wayland_selection,
                                    CdkWindow           *window,
                                    CdkAtom              selection,
                                    CdkAtom              target,
                                    gint                 fd)
989{
StoredSelection *stored_selection;
AsyncWriteData *write_data;

if (!window ||
    !cdk_wayland_selection_source_handles_target (wayland_selection, target))
  {
    close (fd);
    return FALSE(0);
  }

stored_selection =
  cdk_wayland_selection_find_stored_selection (wayland_selection, window,
                                               selection, target);

if (stored_selection && stored_selection->data)
  {
    /* Fast path, we already have the type cached */
    write_data = async_write_data_new (stored_selection, fd);
    async_write_data_write (write_data);
    return TRUE(!(0));
  }

if (!stored_selection)
  {
    stored_selection = stored_selection_new (wayland_selection, window,
                                             selection, target);
    g_ptr_array_add (wayland_selection->stored_selections, stored_selection);
  }

write_data = async_write_data_new (stored_selection, fd);

if (!wayland_selection->current_request_selection)
  cdk_wayland_selection_handle_next_request (wayland_selection);

return TRUE(!(0));
1025}

1027static void
1028data_source_target (void                  *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                  struct wl_data_source *source,
                  const char            *mime_type)
1031{
CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source target, source = %p, mime_type = %s", source, mime_type
); }; } while (0)
          g_message ("data source target, source = %p, mime_type = %s",do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source target, source = %p, mime_type = %s", source, mime_type
); }; } while (0)
                     source, mime_type))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source target, source = %p, mime_type = %s", source, mime_type
); }; } while (0);
1035}

1037static void
1038data_source_send (void                  *data,
                struct wl_data_source *source,
                const char            *mime_type,
                int32_t                fd)
1042{
CdkWaylandSelection *wayland_selection = data;
CdkWindow *window;
CdkAtom selection;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source send, source = %p, mime_type = %s, fd = %d", source
, mime_type, fd); }; } while (0)
          g_message ("data source send, source = %p, mime_type = %s, fd = %d",do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source send, source = %p, mime_type = %s, fd = %d", source
, mime_type, fd); }; } while (0)
                     source, mime_type, fd))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source send, source = %p, mime_type = %s, fd = %d", source
, mime_type, fd); }; } while (0);

if (!mime_type)
  {
    close (fd);
    return;
  }

if (source == wayland_selection->dnd_source)
  {
    window = wayland_selection->dnd_owner;
    selection = atoms[ATOM_DND];
  }
else if (source == wayland_selection->clipboard_source)
  {
    window = wayland_selection->clipboard_owner;
    selection = atoms[ATOM_CLIPBOARD];
  }
else
  {
    close (fd);
    return;
  }

if (!window)
  return;

cdk_wayland_selection_request_target (wayland_selection, window,
                                      selection,
                                      cdk_atom_intern (mime_type, FALSE(0)),
                                      fd);
1080}

1082static void
1083data_source_cancelled (void                  *data,
                     struct wl_data_source *source)
1085{
CdkWaylandSelection *wayland_selection = data;
CdkDragContext *context;
CdkDisplay *display;
CdkAtom atom;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source cancelled, source = %p", source); }; } while (
0)
          g_message ("data source cancelled, source = %p", source))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source cancelled, source = %p", source); }; } while (
0);

display = cdk_display_get_default ();

if (source == wayland_selection->dnd_source)
  atom = atoms[ATOM_DND];
else if (source == wayland_selection->clipboard_source)
  atom = atoms[ATOM_CLIPBOARD];
else
  return;

context = cdk_wayland_drag_context_lookup_by_data_source (source);

if (context)
  cdk_drag_context_cancel (context, CDK_DRAG_CANCEL_ERROR);

emit_selection_clear (display, atom);
cdk_selection_owner_set (NULL((void*)0), atom, CDK_CURRENT_TIME0L, FALSE(0));
cdk_wayland_selection_unset_data_source (display, atom);
1111}

1113static void
1114data_source_dnd_drop_performed (void                  *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                              struct wl_data_source *source)
1116{
CdkDragContext *context;

context = cdk_wayland_drag_context_lookup_by_data_source (source);

if (!context)
  return;

g_signal_emit_by_name (context, "drop-performed", CDK_CURRENT_TIME0L);
1125}

1127static void
1128data_source_dnd_finished (void                  *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                        struct wl_data_source *source)
1130{
CdkDisplay *display = cdk_display_get_default ();
CdkDragContext *context;

context = cdk_wayland_drag_context_lookup_by_data_source (source);

if (!context)
  return;

if (context->action == CDK_ACTION_MOVE)
  {
    cdk_wayland_selection_emit_request (context->source_window,
                                        atoms[ATOM_DND],
                                        cdk_atom_intern_static_string ("DELETE"));
  }

g_signal_emit_by_name (context, "dnd-finished");
cdk_selection_owner_set (NULL((void*)0), atoms[ATOM_DND], CDK_CURRENT_TIME0L, TRUE(!(0)));
cdk_wayland_selection_clear_targetscdk_wayland_selection_clear_targets_libctk_only (display, atoms[ATOM_DND]);
1149}

1151static void
1152data_source_action (void                  *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                  struct wl_data_source *source,
                  uint32_t               action)
1155{
CdkDragContext *context;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source action, source = %p action=%x", source, action
); }; } while (0)
          g_message ("data source action, source = %p action=%x",do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source action, source = %p action=%x", source, action
); }; } while (0)
                     source, action))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("data source action, source = %p action=%x", source, action
); }; } while (0);

context = cdk_wayland_drag_context_lookup_by_data_source (source);

if (!context)
  return;

context->action = _wl_to_cdk_actions (action);
g_signal_emit_by_name (context, "action-changed", context->action);
1169}

1171static const struct wl_data_source_listener data_source_listener = {
data_source_target,
data_source_send,
data_source_cancelled,
data_source_dnd_drop_performed,
data_source_dnd_finished,
data_source_action,
1178};

1180static void
1181primary_source_send (void       *data,
                   gpointer    source,
                   const char *mime_type,
                   int32_t     fd)
1185{
CdkWaylandSelection *wayland_selection = data;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary source send, source = %p, mime_type = %s, fd = %d"
, source, mime_type, fd); }; } while (0)
          g_message ("primary source send, source = %p, mime_type = %s, fd = %d",do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary source send, source = %p, mime_type = %s, fd = %d"
, source, mime_type, fd); }; } while (0)
                     source, mime_type, fd))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary source send, source = %p, mime_type = %s, fd = %d"
, source, mime_type, fd); }; } while (0);

if (!mime_type || !wayland_selection->primary_owner)
  {
    close (fd);
    return;
  }

cdk_wayland_selection_request_target (wayland_selection,
                                      wayland_selection->primary_owner,
                                      atoms[ATOM_PRIMARY],
                                      cdk_atom_intern (mime_type, FALSE(0)),
                                      fd);
1203}

1205static void
1206ctk_primary_source_send (void                                *data,
                       struct ctk_primary_selection_source *source,
                       const char                          *mime_type,
                       int32_t                              fd)
1210{
primary_source_send (data, (gpointer) source, mime_type, fd);
1212}

1214static void
1215zwp_primary_source_v1_send (void                                   *data,
                          struct zwp_primary_selection_source_v1 *source,
                          const char                             *mime_type,
                          int32_t                                 fd)
1219{
primary_source_send (data, (gpointer) source, mime_type, fd);
1221}

1223static void
1224primary_source_cancelled (void     *data G_GNUC_UNUSED__attribute__ ((__unused__)),
                        gpointer  source)
1226{
CdkDisplay *display;
CdkAtom atom;

CDK_NOTE (EVENTS,do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary source cancelled, source = %p", source); }; } while
 (0)
          g_message ("primary source cancelled, source = %p", source))do { if ((_cdk_debug_flags & CDK_DEBUG_EVENTS)) { g_message
 ("primary source cancelled, source = %p", source); }; } while
 (0);

display = cdk_display_get_default ();

atom = atoms[ATOM_PRIMARY];
emit_selection_clear (display, atom);
cdk_selection_owner_set (NULL((void*)0), atom, CDK_CURRENT_TIME0L, FALSE(0));
cdk_wayland_selection_unset_data_source (display, atom);
1239}

1241static void
1242ctk_primary_source_cancelled (void                                *data,
                            struct ctk_primary_selection_source *source)
1244{
primary_source_cancelled (data, source);
1246}

1248static void
1249zwp_primary_source_v1_cancelled (void                                   *data,
                               struct zwp_primary_selection_source_v1 *source)
1251{
primary_source_cancelled (data, source);
1253}

1255static const struct ctk_primary_selection_source_listener ctk_primary_source_listener = {
ctk_primary_source_send,
ctk_primary_source_cancelled,
1258};

1260static const struct zwp_primary_selection_source_v1_listener zwp_primary_source_v1_listener = {
zwp_primary_source_v1_send,
zwp_primary_source_v1_cancelled,
1263};

1265struct wl_data_source *
1266cdk_wayland_selection_get_data_source (CdkWindow *owner,
                                     CdkAtom    selection)
1268{
CdkDisplay *display = cdk_window_get_display (owner);
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);
gpointer source = NULL((void*)0);
CdkWaylandDisplay *display_wayland;

if (selection == atoms[ATOM_DND])
  {
    if (wayland_selection->dnd_source &&
        (!owner || owner == wayland_selection->dnd_owner))
      return wayland_selection->dnd_source;
  }
else if (selection == atoms[ATOM_PRIMARY])
  {
    if (wayland_selection->primary_source &&
        (!owner || owner == wayland_selection->primary_owner))
      return wayland_selection->primary_source;

    if (wayland_selection->primary_source)
      {
        primary_selection_source_destroy (wayland_selection->primary_source);
        wayland_selection->primary_source = NULL((void*)0);
      }
  }
else if (selection == atoms[ATOM_CLIPBOARD])
  {
    if (wayland_selection->clipboard_source &&
        (!owner || owner == wayland_selection->clipboard_owner))
      return wayland_selection->clipboard_source;

    if (wayland_selection->clipboard_source)
      {
        wl_data_source_destroy (wayland_selection->clipboard_source);
        wayland_selection->clipboard_source = NULL((void*)0);
      }
  }
else
  return NULL((void*)0);

if (!owner)
  return NULL((void*)0);

display_wayland = CDK_WAYLAND_DISPLAY (cdk_window_get_display (owner))((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((cdk_window_get_display (owner))), ((cdk_wayland_display_get_type
()))))));

if (selection == atoms[ATOM_PRIMARY])
  {
    if (display_wayland->zwp_primary_selection_manager_v1)
      {
        source = zwp_primary_selection_device_manager_v1_create_source (display_wayland->zwp_primary_selection_manager_v1);
        zwp_primary_selection_source_v1_add_listener (source,
                                                      &zwp_primary_source_v1_listener,
                                                      wayland_selection);
      }
    else if (display_wayland->ctk_primary_selection_manager)
      {
        source = ctk_primary_selection_device_manager_create_source (display_wayland->ctk_primary_selection_manager);
        ctk_primary_selection_source_add_listener (source,
                                                   &ctk_primary_source_listener,
                                                   wayland_selection);
      }
  }
else
  {
    source = wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
    wl_data_source_add_listener (source,
                                 &data_source_listener,
                                 wayland_selection);
  }

if (selection == atoms[ATOM_DND])
  wayland_selection->dnd_source = source;
else if (selection == atoms[ATOM_PRIMARY])
  wayland_selection->primary_source = source;
else if (selection == atoms[ATOM_CLIPBOARD])
  wayland_selection->clipboard_source = source;

return source;
1345}

1347void
1348cdk_wayland_selection_unset_data_source (CdkDisplay *display,
                                       CdkAtom     selection)
1350{
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);

if (selection == atoms[ATOM_CLIPBOARD])
  {
    if (wayland_selection->clipboard_source)
      {
        wl_data_source_destroy (wayland_selection->clipboard_source);
        wayland_selection->clipboard_source = NULL((void*)0);
      }
  }
else if (selection == atoms[ATOM_PRIMARY])
  {
    if (wayland_selection->primary_source)
      {
        primary_selection_source_destroy (wayland_selection->primary_source);
        wayland_selection->primary_source = NULL((void*)0);
      }
  }
else if (selection == atoms[ATOM_DND])
  {
    wayland_selection->dnd_source = NULL((void*)0);
  }
1373}

1375CdkWindow *
1376_cdk_wayland_display_get_selection_owner (CdkDisplay *display,
                                        CdkAtom     selection)
1378{
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);

if (selection == atoms[ATOM_CLIPBOARD])
  return wayland_selection->clipboard_owner;
else if (selection == atoms[ATOM_PRIMARY])
  return wayland_selection->primary_owner;
else if (selection == atoms[ATOM_DND])
  return wayland_selection->dnd_owner;

return NULL((void*)0);
1389}

1391gboolean
1392_cdk_wayland_display_set_selection_owner (CdkDisplay *display,
                                        CdkWindow  *owner,
                                        CdkAtom     selection,
                                        guint32     time G_GNUC_UNUSED__attribute__ ((__unused__)),
                                        gboolean    send_event)
1397{
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);
CdkSeat *seat = cdk_display_get_default_seat (display);

cdk_wayland_selection_reset_selection (wayland_selection, selection);

if (selection == atoms[ATOM_CLIPBOARD])
  {
    wayland_selection->clipboard_owner = owner;
    if (send_event && !owner)
      {
        cdk_wayland_seat_set_selection (seat, NULL((void*)0));
        cdk_wayland_selection_unset_data_source (display, selection);
      }
    return TRUE(!(0));
  }
else if (selection == atoms[ATOM_PRIMARY])
  {
    wayland_selection->primary_owner = owner;
    if (send_event && !owner)
      {
        cdk_wayland_seat_set_primary (seat, NULL((void*)0));
        cdk_wayland_selection_unset_data_source (display, selection);
      }
    return TRUE(!(0));
  }
else if (selection == atoms[ATOM_DND])
  {
    wayland_selection->dnd_owner = owner;
    return TRUE(!(0));
  }

return FALSE(0);
1430}

1432void
1433_cdk_wayland_display_send_selection_notify (CdkDisplay *display,
                                          CdkWindow  *requestor G_GNUC_UNUSED__attribute__ ((__unused__)),
                                          CdkAtom     selection G_GNUC_UNUSED__attribute__ ((__unused__)),
                                          CdkAtom     target G_GNUC_UNUSED__attribute__ ((__unused__)),
                                          CdkAtom     property,
                                          guint32     time G_GNUC_UNUSED__attribute__ ((__unused__)))
1439{
CdkWaylandSelection *wayland_selection;

if (property != CDK_NONE((CdkAtom)((gpointer) (gulong) (0))))
  return;

wayland_selection = cdk_wayland_display_get_selection (display);

if (!wayland_selection->current_request_selection)
  return;

g_ptr_array_remove_fast (wayland_selection->stored_selections,
                         wayland_selection->current_request_selection);

/* Handle the next CDK_SELECTION_REQUEST / store, if any */
wayland_selection->current_request_selection = NULL((void*)0);
cdk_wayland_selection_handle_next_request (wayland_selection);
1456}

1458gint
1459_cdk_wayland_display_get_selection_property (CdkDisplay  *display G_GNUC_UNUSED__attribute__ ((__unused__)),
                                           CdkWindow   *requestor,
                                           guchar     **data,
                                           CdkAtom     *ret_type,
                                           gint        *ret_format)
1464{
SelectionBuffer *buffer_data;
gsize len;

buffer_data = cdk_wayland_selection_lookup_requestor_buffer (requestor);

if (!buffer_data)
1
Assuming 'buffer_data' is non-null→
2
←
Taking false branch→
  return 0;

selection_buffer_remove_requestor (buffer_data, requestor);
len = buffer_data->data->len;

if (data)
3
←
Assuming 'data' is null→
4
←
Taking false branch→
  {
    guchar *buffer;

    buffer = g_new0 (guchar, len + 1)((guchar *) g_malloc0_n ((len + 1), sizeof (guchar)));
    memcpy (buffer, buffer_data->data->data, len);
    *data = buffer;
  }

if (buffer_data->target == cdk_atom_intern_static_string ("TARGETS"))
5
←
Assuming the condition is true→
6
←
Taking true branch→
  {
    if (ret_type)
7
←
Assuming 'ret_type' is non-null→
8
←
Taking true branch→
      *ret_type = CDK_SELECTION_TYPE_ATOM((CdkAtom)((gpointer) (gulong) (4)));
9
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
    if (ret_format)
      *ret_format = 32;
  }
else
  {
    if (ret_type)
      *ret_type = buffer_data->target;
    if (ret_format)
      *ret_format = 8;
  }

return len;
1501}

1503static void
1504emit_empty_selection_notify (CdkWindow *requestor,
                           CdkAtom    selection,
                           CdkAtom    target)
1507{
CdkEvent *event;

event = cdk_event_new (CDK_SELECTION_NOTIFY);
event->selection.window = g_object_ref (requestor)((__typeof__ (requestor)) (g_object_ref) (requestor));
event->selection.send_event = FALSE(0);
event->selection.selection = selection;
event->selection.target = target;
event->selection.property = CDK_NONE((CdkAtom)((gpointer) (gulong) (0)));
event->selection.time = CDK_CURRENT_TIME0L;
event->selection.requestor = g_object_ref (requestor)((__typeof__ (requestor)) (g_object_ref) (requestor));

cdk_event_put (event);
cdk_event_free (event);
1521}

1523static void
1524emit_selection_clear (CdkDisplay *display,
                    CdkAtom     selection)
1526{
CdkEvent *event;
CdkWindow *window;

event = cdk_event_new (CDK_SELECTION_CLEAR);
event->selection.selection = selection;
event->selection.time = CDK_CURRENT_TIME0L;

window = _cdk_wayland_display_get_selection_owner (display, selection);
if (window != NULL((void*)0))
  {
    event->selection.window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
    event->selection.requestor = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
  }

cdk_event_put (event);
cdk_event_free (event);
1543}

1545void
1546_cdk_wayland_display_convert_selection (CdkDisplay *display,
                                      CdkWindow  *requestor,
                                      CdkAtom     selection,
                                      CdkAtom     target,
                                      guint32     time G_GNUC_UNUSED__attribute__ ((__unused__)))
1551{
CdkWaylandDisplay *display_wayland = CDK_WAYLAND_DISPLAY (display)((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((display)), ((cdk_wayland_display_get_type(
)))))));
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);
const SelectionData *selection_data;
SelectionBuffer *buffer_data;
gpointer offer;
gchar *mimetype;
GList *target_list;

selection_data = selection_lookup_offer_by_atom (wayland_selection, selection);
if (!selection_data)
  {
    emit_empty_selection_notify (requestor, selection, target);
    return;
  }

offer = cdk_wayland_selection_get_offer (display, selection);
target_list = cdk_wayland_selection_get_targets (display, selection);

if (!offer || target == cdk_atom_intern_static_string ("DELETE"))
  {
    emit_empty_selection_notify (requestor, selection, target);
    return;
  }

mimetype = cdk_atom_name (target);

if (target != cdk_atom_intern_static_string ("TARGETS"))
  {
    if (!g_list_find (target_list, CDK_ATOM_TO_POINTER (target)(target)))
      {
        emit_empty_selection_notify (requestor, selection, target);
        return;
      }

    if (selection != atoms[ATOM_PRIMARY])
      wl_data_offer_accept (offer,
                            _cdk_wayland_display_get_serial (CDK_WAYLAND_DISPLAY (display)((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((display)), ((cdk_wayland_display_get_type(
)))))))),
                            mimetype);
  }

buffer_data = g_hash_table_lookup (selection_data->buffers, target);

if (buffer_data)
  selection_buffer_add_requestor (buffer_data, requestor);
else
  {
    GInputStream *stream = NULL((void*)0);
    int natoms = 0;
    CdkAtom *targets = NULL((void*)0);

    if (target == cdk_atom_intern_static_string ("TARGETS"))
      {
        gint i = 0;
        GList *l;

        natoms = g_list_length (target_list);
        targets = g_new0 (CdkAtom, natoms)((CdkAtom *) g_malloc0_n ((natoms), sizeof (CdkAtom)));

        for (l = target_list; l; l = l->next)
          targets[i++] = l->data;
      }
    else
      {
        int pipe_fd[2];

        g_unix_open_pipe (pipe_fd, FD_CLOEXEC1, NULL((void*)0));

        if (selection == atoms[ATOM_PRIMARY])
          {
            if (display_wayland->zwp_primary_selection_manager_v1)
              zwp_primary_selection_offer_v1_receive (offer, mimetype, pipe_fd[1]);
            else if (display_wayland->ctk_primary_selection_manager)
              ctk_primary_selection_offer_receive (offer, mimetype, pipe_fd[1]);
          }
        else
          {
            wl_data_offer_receive (offer, mimetype, pipe_fd[1]);
          }

        stream = g_unix_input_stream_new (pipe_fd[0], TRUE(!(0)));
        close (pipe_fd[1]);
      }

    buffer_data = selection_buffer_new (stream, selection, target);
    selection_buffer_add_requestor (buffer_data, requestor);

    if (stream)
      g_object_unref (stream);

    if (targets)
      {
        /* Store directly the local atoms */
        selection_buffer_append_data (buffer_data, targets, natoms * sizeof (CdkAtom));
        g_free (targets);
      }

    g_hash_table_insert (selection_data->buffers,
                         CDK_ATOM_TO_POINTER (target)(target),
                         buffer_data);
  }

if (!buffer_data->stream)
  selection_buffer_notify (buffer_data);

g_free (mimetype);
1657}

1659gint
1660_cdk_wayland_display_text_property_to_utf8_list (CdkDisplay    *display G_GNUC_UNUSED__attribute__ ((__unused__)),
                                               CdkAtom        encoding G_GNUC_UNUSED__attribute__ ((__unused__)),
                                               gint           format G_GNUC_UNUSED__attribute__ ((__unused__)),
                                               const guchar  *text,
                                               gint           length,
                                               gchar       ***list)
1666{
GPtrArray *array;
const gchar *ptr;
gsize chunk_len;
gchar *copy;
guint nitems;

ptr = (const gchar *) text;
array = g_ptr_array_new ();

while (ptr < (const gchar *) &text[length])
  {
    chunk_len = strlen (ptr);

    if (g_utf8_validate (ptr, chunk_len, NULL((void*)0)))
      {
        copy = g_strndup (ptr, chunk_len);
        g_ptr_array_add (array, copy);
      }

    ptr = &ptr[chunk_len + 1];
  }

nitems = array->len;
g_ptr_array_add (array, NULL((void*)0));

if (list)
  *list = (gchar **) g_ptr_array_free (array, FALSE(0));
else
  g_ptr_array_free (array, TRUE(!(0)));

return nitems;
1698}

1700/* This function has been copied straight from the x11 backend */
1701static gchar *
1702sanitize_utf8 (const gchar *src,
             gboolean return_latin1)
1704{
gint len = strlen (src);
GString *result = g_string_sized_new (len);
const gchar *p = src;

while (*p)
  {
    if (*p == '\r')
      {
        p++;
        if (*p == '\n')
          p++;

        g_string_append_c (result, '\n')g_string_append_c_inline (result, '\n');
      }
    else
      {
        gunichar ch = g_utf8_get_char (p);

        if (!((ch < 0x20 && ch != '\t' && ch != '\n') || (ch >= 0x7f && ch < 0xa0)))
          {
            if (return_latin1)
              {
                if (ch <= 0xff)
                  g_string_append_c (result, ch)g_string_append_c_inline (result, ch);
                else
                  g_string_append_printf (result,
                                          ch < 0x10000 ? "\\u%04x" : "\\U%08x",
                                          ch);
              }
            else
              {
                char buf[7];
                gint buflen;

                buflen = g_unichar_to_utf8 (ch, buf);
                g_string_append_len (result, buf, buflen)g_string_append_len_inline (result, buf, buflen);
              }
          }

        p = g_utf8_next_char (p)((p) + g_utf8_skip[*(const guchar *)(p)]);
      }
  }

return g_string_free (result, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((result
), ((0))) : g_string_free_and_steal (result)) : (g_string_free
) ((result), ((0))));
1749}

1751gchar *
1752_cdk_wayland_display_utf8_to_string_target (CdkDisplay  *display G_GNUC_UNUSED__attribute__ ((__unused__)),
                                          const gchar *str)
1754{
/* This is mainly needed when interfacing with old clients through
 * Xwayland, the STRING target could be used, and passed as-is
 * by the compositor.
 *
 * There's already some handling of this atom (aka "mimetype" in
 * this backend) in common code, so we end up in this vfunc.
 */
return sanitize_utf8 (str, TRUE(!(0)));
1763}

1765void
1766cdk_wayland_selection_add_targetscdk_wayland_selection_add_targets_libctk_only (CdkWindow *window,
                                 CdkAtom    selection,
                                 guint      ntargets,
                                 CdkAtom   *targets)
1770{
CdkDisplay *display = cdk_window_get_display (window);
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);
gpointer data_source;
guint i;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_window_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

data_source = cdk_wayland_selection_get_data_source (window, selection);

if (!data_source)
  return;

g_array_append_vals (wayland_selection->source_targets, targets, ntargets);

for (i = 0; i < ntargets; i++)
  {
    gchar *mimetype = cdk_atom_name (targets[i]);

    wl_data_source_offer (data_source, mimetype);
    g_free (mimetype);
  }

if (selection == atoms[ATOM_CLIPBOARD])
  {
    CdkSeat *seat;

    seat = cdk_display_get_default_seat (display);
    cdk_wayland_seat_set_selection (seat, data_source);
  }
else if (selection == atoms[ATOM_PRIMARY])
  {
    CdkSeat *seat;

    seat = cdk_display_get_default_seat (display);
    cdk_wayland_seat_set_primary (seat, data_source);
  }
1807}

1809void
1810cdk_wayland_selection_clear_targetscdk_wayland_selection_clear_targets_libctk_only (CdkDisplay *display,
                                   CdkAtom     selection)
1812{
CdkWaylandSelection *wayland_selection = cdk_wayland_display_get_selection (display);

wayland_selection->requested_target = CDK_NONE((CdkAtom)((gpointer) (gulong) (0)));
g_array_set_size (wayland_selection->source_targets, 0);
cdk_wayland_selection_unset_data_source (display, selection);
1818}

1820gboolean
1821cdk_wayland_selection_set_current_offer_actions (CdkDisplay *display,
                                               uint32_t    action)
1823{
CdkWaylandDisplay *display_wayland = CDK_WAYLAND_DISPLAY (display)((((CdkWaylandDisplay*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((display)), ((cdk_wayland_display_get_type(
)))))));
struct wl_data_offer *offer;
uint32_t all_actions = 0;

offer = cdk_wayland_selection_get_offer (display, atoms[ATOM_DND]);

if (!offer)
  return FALSE(0);

if (action != 0)
  all_actions = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY |
    WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE |
    WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;

if (display_wayland->data_device_manager_version >=
    WL_DATA_OFFER_SET_ACTIONS_SINCE_VERSION3)
  wl_data_offer_set_actions (offer, all_actions, action);
return TRUE(!(0));
1842}