server/clipboard.c

   1 /*
   2  * Server-side clipboard management
   3  *
   4  * Copyright 2002 Ulrich Czekalla
   5  * Copyright 2016 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "request.h"
  33 #include "object.h"
  34 #include "file.h"
  35 #include "process.h"
  36 #include "user.h"
  37 #include "winuser.h"
  38 #include "winternl.h"
  39
  40 struct clip_format
  41 {
  42     struct list    entry;            /* entry in format list */
  43     unsigned int   id;               /* format id */
  44     unsigned int   from;             /* for synthesized data, format to generate it from */
  45     unsigned int   seqno;            /* sequence number when the data was set */
  46     data_size_t    size;             /* size of the data block */
  47     void          *data;             /* data contents, or NULL for delay-rendered */
  48 };
  49
  50 struct clipboard
  51 {
  52     struct object  obj;              /* object header */
  53     struct thread *open_thread;      /* thread id that has clipboard open */
  54     user_handle_t  open_win;         /* window that has clipboard open */
  55     user_handle_t  owner;            /* window that owns the clipboard */
  56     user_handle_t  viewer;           /* first window in clipboard viewer list */
  57     unsigned int   lcid;             /* locale id to use for synthesizing text formats */
  58     unsigned int   seqno;            /* clipboard change sequence number */
  59     unsigned int   open_seqno;       /* sequence number at open time */
  60     unsigned int   rendering;        /* format rendering recursion counter */
  61     struct list    formats;          /* list of data formats */
  62     unsigned int   format_count;     /* count of data formats */
  63     unsigned int   format_map;       /* existence bitmap for formats < CF_MAX */
  64     unsigned int   listen_size;      /* size of listeners array */
  65     unsigned int   listen_count;     /* count of listeners */
  66     user_handle_t *listeners;        /* array of listener windows */
  67 };
  68
  69 static void clipboard_dump( struct object *obj, int verbose );
  70 static void clipboard_destroy( struct object *obj );
  71
  72 static const struct object_ops clipboard_ops =
  73 {
  74     sizeof(struct clipboard),     /* size */
  75     clipboard_dump,               /* dump */
  76     no_get_type,                  /* get_type */
  77     no_add_queue,                 /* add_queue */
  78     NULL,                         /* remove_queue */
  79     NULL,                         /* signaled */
  80     NULL,                         /* satisfied */
  81     no_signal,                    /* signal */
  82     no_get_fd,                    /* get_fd */
  83     no_map_access,                /* map_access */
  84     default_get_sd,               /* get_sd */
  85     default_set_sd,               /* set_sd */
  86     no_lookup_name,               /* lookup_name */
  87     no_link_name,                 /* link_name */
  88     NULL,                         /* unlink_name */
  89     no_open_file,                 /* open_file */
  90     no_close_handle,              /* close_handle */
  91     clipboard_destroy             /* destroy */
  92 };
  93
  94
  95 #define HAS_FORMAT(map,id) ((map) & (1 << (id)))  /* only for formats < CF_MAX */
  96
  97 /* find a data format in the clipboard */
  98 static struct clip_format *get_format( struct clipboard *clipboard, unsigned int id )
  99 {
 100     struct clip_format *format;
 101
 102     LIST_FOR_EACH_ENTRY( format, &clipboard->formats, struct clip_format, entry )
 103         if (format->id == id) return format;
 104
 105     return NULL;
 106 }
 107
 108 /* add a data format to the clipboard */
 109 static struct clip_format *add_format( struct clipboard *clipboard, unsigned int id )
 110 {
 111     struct clip_format *format;
 112
 113     if (!(format = mem_alloc( sizeof(*format )))) return NULL;
 114     format->id   = id;
 115     format->from = 0;
 116     format->size = 0;
 117     format->data = NULL;
 118     list_add_tail( &clipboard->formats, &format->entry );
 119     clipboard->format_count++;
 120     if (id < CF_MAX) clipboard->format_map |= 1 << id;
 121     return format;
 122 }
 123
 124 /* free all clipboard formats */
 125 static void free_clipboard_formats( struct clipboard *clipboard )
 126 {
 127     struct clip_format *format, *next;
 128
 129     LIST_FOR_EACH_ENTRY_SAFE( format, next, &clipboard->formats, struct clip_format, entry )
 130     {
 131         list_remove( &format->entry );
 132         free( format->data );
 133         free( format );
 134     }
 135     clipboard->format_count = 0;
 136     clipboard->format_map = 0;
 137 }
 138
 139 /* dump a clipboard object */
 140 static void clipboard_dump( struct object *obj, int verbose )
 141 {
 142     struct clipboard *clipboard = (struct clipboard *)obj;
 143
 144     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner=%08x viewer=%08x seq=%u\n",
 145              clipboard->open_thread, clipboard->open_win,
 146              clipboard->owner, clipboard->viewer, clipboard->seqno );
 147 }
 148
 149 static void clipboard_destroy( struct object *obj )
 150 {
 151     struct clipboard *clipboard = (struct clipboard *)obj;
 152
 153     free( clipboard->listeners );
 154     free_clipboard_formats( clipboard );
 155 }
 156
 157 /* retrieve the clipboard info for the current process, allocating it if needed */
 158 static struct clipboard *get_process_clipboard(void)
 159 {
 160     struct clipboard *clipboard;
 161     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
 162
 163     if (!winstation) return NULL;
 164
 165     if (!(clipboard = winstation->clipboard))
 166     {
 167         if ((clipboard = alloc_object( &clipboard_ops )))
 168         {
 169             clipboard->open_thread = NULL;
 170             clipboard->open_win = 0;
 171             clipboard->owner = 0;
 172             clipboard->viewer = 0;
 173             clipboard->seqno = 0;
 174             clipboard->format_count = 0;
 175             clipboard->format_map = 0;
 176             clipboard->listen_size = 0;
 177             clipboard->listen_count = 0;
 178             clipboard->listeners = NULL;
 179             list_init( &clipboard->formats );
 180             winstation->clipboard = clipboard;
 181         }
 182     }
 183     release_object( winstation );
 184     return clipboard;
 185 }
 186
 187 /* add synthesized formats upon clipboard close */
 188 static int synthesize_formats( struct clipboard *clipboard )
 189 {
 190     static const unsigned int formats[][3] =
 191     {
 192         { CF_TEXT, CF_OEMTEXT, CF_UNICODETEXT },
 193         { CF_OEMTEXT, CF_UNICODETEXT, CF_TEXT },
 194         { CF_UNICODETEXT, CF_TEXT, CF_OEMTEXT },
 195         { CF_METAFILEPICT, CF_ENHMETAFILE },
 196         { CF_ENHMETAFILE, CF_METAFILEPICT },
 197         { CF_BITMAP, CF_DIB, CF_DIBV5 },
 198         { CF_DIB, CF_BITMAP, CF_DIBV5 },
 199         { CF_DIBV5, CF_BITMAP, CF_DIB }
 200     };
 201     unsigned int i, from, total = 0, map = clipboard->format_map;
 202     struct clip_format *format;
 203
 204     if (!HAS_FORMAT( map, CF_LOCALE ) &&
 205         (HAS_FORMAT( map, CF_TEXT ) || HAS_FORMAT( map, CF_OEMTEXT ) || HAS_FORMAT( map, CF_UNICODETEXT )))
 206     {
 207         void *data = memdup( &clipboard->lcid, sizeof(clipboard->lcid) );
 208         if (data && (format = add_format( clipboard, CF_LOCALE )))
 209         {
 210             format->seqno = clipboard->seqno++;
 211             format->data  = data;
 212             format->size  = sizeof(clipboard->lcid);
 213         }
 214         else free( data );
 215     }
 216
 217     for (i = 0; i < sizeof(formats) / sizeof(formats[0]); i++)
 218     {
 219         if (HAS_FORMAT( map, formats[i][0] )) continue;
 220         if (HAS_FORMAT( map, formats[i][1] )) from = formats[i][1];
 221         else if (HAS_FORMAT( map, formats[i][2] )) from = formats[i][2];
 222         else continue;
 223         if (!(format = add_format( clipboard, formats[i][0] ))) continue;
 224         format->from = from;
 225         format->seqno = clipboard->seqno;
 226         total++;
 227     }
 228     return total;
 229 }
 230
 231 /* add a clipboard listener */
 232 static void add_listener( struct clipboard *clipboard, user_handle_t window )
 233 {
 234     unsigned int i;
 235
 236     for (i = 0; i < clipboard->listen_count; i++)
 237     {
 238         if (clipboard->listeners[i] != window) continue;
 239         set_error( STATUS_INVALID_PARAMETER );  /* already set */
 240         return;
 241     }
 242     if (clipboard->listen_size == clipboard->listen_count)
 243     {
 244         unsigned int new_size = max( 8, clipboard->listen_size * 2 );
 245         user_handle_t *new = realloc( clipboard->listeners, new_size * sizeof(*new) );
 246         if (!new)
 247         {
 248             set_error( STATUS_NO_MEMORY );
 249             return;
 250         }
 251         clipboard->listeners = new;
 252         clipboard->listen_size = new_size;
 253     }
 254     clipboard->listeners[clipboard->listen_count++] = window;
 255 }
 256
 257 /* remove a clipboard listener */
 258 static int remove_listener( struct clipboard *clipboard, user_handle_t window )
 259 {
 260     unsigned int i;
 261
 262     for (i = 0; i < clipboard->listen_count; i++)
 263     {
 264         if (clipboard->listeners[i] != window) continue;
 265         memmove( clipboard->listeners + i, clipboard->listeners + i + 1,
 266                  (clipboard->listen_count - i - 1) * sizeof(*clipboard->listeners) );
 267         clipboard->listen_count--;
 268         return 1;
 269     }
 270     return 0;
 271 }
 272
 273 /* notify all listeners, and return the viewer window that should be notified if any */
 274 static user_handle_t notify_listeners( struct clipboard *clipboard )
 275 {
 276     unsigned int i;
 277
 278     for (i = 0; i < clipboard->listen_count; i++)
 279         post_message( clipboard->listeners[i], WM_CLIPBOARDUPDATE, 0, 0 );
 280     return clipboard->viewer;
 281 }
 282
 283 /* close the clipboard, and return the viewer window that should be notified if any */
 284 static user_handle_t close_clipboard( struct clipboard *clipboard )
 285 {
 286     clipboard->open_win = 0;
 287     clipboard->open_thread = NULL;
 288     if (clipboard->seqno == clipboard->open_seqno) return 0;  /* unchanged */
 289     if (synthesize_formats( clipboard )) clipboard->seqno++;
 290     return notify_listeners( clipboard );
 291 }
 292
 293 /* release the clipboard owner, and return the viewer window that should be notified if any */
 294 static user_handle_t release_clipboard( struct clipboard *clipboard )
 295 {
 296     struct clip_format *format, *next;
 297     int changed = 0;
 298
 299     clipboard->owner = 0;
 300
 301     /* free the delayed-rendered formats, since we no longer have an owner to render them */
 302     LIST_FOR_EACH_ENTRY_SAFE( format, next, &clipboard->formats, struct clip_format, entry )
 303     {
 304         if (format->data || format->from) continue;
 305         list_remove( &format->entry );
 306         if (format->id < CF_MAX) clipboard->format_map &= ~(1 << format->id);
 307         clipboard->format_count--;
 308         free( format );
 309         changed = 1;
 310     }
 311
 312     if (!changed) return 0;
 313     clipboard->seqno++;
 314     return notify_listeners( clipboard );
 315 }
 316
 317 /* cleanup clipboard information upon window destruction */
 318 void cleanup_clipboard_window( struct desktop *desktop, user_handle_t window )
 319 {
 320     struct clipboard *clipboard = desktop->winstation->clipboard;
 321
 322     if (!clipboard) return;
 323
 324     remove_listener( clipboard, window );
 325     if (clipboard->viewer == window) clipboard->viewer = 0;
 326     if (clipboard->owner == window) release_clipboard( clipboard );
 327     if (clipboard->open_win == window)
 328     {
 329         user_handle_t viewer = close_clipboard( clipboard );
 330         if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner, 0 );
 331     }
 332 }
 333
 334 /* Called when thread terminates to allow release of clipboard */
 335 void cleanup_clipboard_thread(struct thread *thread)
 336 {
 337     struct clipboard *clipboard;
 338     struct winstation *winstation;
 339
 340     if (!thread->process->winstation) return;
 341     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
 342
 343     if ((clipboard = winstation->clipboard))
 344     {
 345         if (thread == clipboard->open_thread)
 346         {
 347             user_handle_t viewer = close_clipboard( clipboard );
 348             if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner, 0 );
 349         }
 350     }
 351     release_object( winstation );
 352 }
 353
 354 /* open the clipboard */
 355 DECL_HANDLER(open_clipboard)
 356 {
 357     struct clipboard *clipboard = get_process_clipboard();
 358     user_handle_t win = 0;
 359
 360     if (!clipboard) return;
 361     if (req->window && !(win = get_valid_window_handle( req->window ))) return;
 362
 363     if (clipboard->open_thread && clipboard->open_win != win)
 364     {
 365         set_error( STATUS_INVALID_LOCK_SEQUENCE );
 366         return;
 367     }
 368
 369     if (!clipboard->open_thread) clipboard->open_seqno = clipboard->seqno; /* first open */
 370     if (clipboard->open_thread != current) clipboard->rendering = 0;
 371     clipboard->open_win = win;
 372     clipboard->open_thread = current;
 373
 374     reply->owner = clipboard->owner;
 375 }
 376
 377
 378 /* close the clipboard */
 379 DECL_HANDLER(close_clipboard)
 380 {
 381     struct clipboard *clipboard = get_process_clipboard();
 382
 383     if (!clipboard) return;
 384
 385     if (clipboard->open_thread != current)
 386     {
 387         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 388         return;
 389     }
 390     reply->viewer = close_clipboard( clipboard );
 391     reply->owner  = clipboard->owner;
 392 }
 393
 394
 395 /* add a data format to the clipboard */
 396 DECL_HANDLER(set_clipboard_data)
 397 {
 398     struct clip_format *format;
 399     struct clipboard *clipboard = get_process_clipboard();
 400     void *data = NULL;
 401
 402     if (!clipboard) return;
 403
 404     if (!req->format || !clipboard->open_thread)
 405     {
 406         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 407         return;
 408     }
 409
 410     if (get_req_data_size() && !(data = memdup( get_req_data(), get_req_data_size() ))) return;
 411
 412     if (!(format = get_format( clipboard, req->format )))
 413     {
 414         if (!(format = add_format( clipboard, req->format )))
 415         {
 416             free( data );
 417             return;
 418         }
 419     }
 420
 421     free( format->data );
 422     format->from   = 0;
 423     format->seqno  = clipboard->seqno;
 424     format->size   = get_req_data_size();
 425     format->data   = data;
 426     if (!clipboard->rendering) clipboard->seqno++;
 427
 428     if (req->format == CF_TEXT || req->format == CF_OEMTEXT || req->format == CF_UNICODETEXT)
 429         clipboard->lcid = req->lcid;
 430
 431     reply->seqno = format->seqno;
 432 }
 433
 434
 435 /* fetch a data format from the clipboard */
 436 DECL_HANDLER(get_clipboard_data)
 437 {
 438     struct clip_format *format;
 439     struct clipboard *clipboard = get_process_clipboard();
 440
 441     if (!clipboard) return;
 442
 443     if (clipboard->open_thread != current)
 444     {
 445         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 446         return;
 447     }
 448     if (!(format = get_format( clipboard, req->format )))
 449     {
 450         set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 451         goto done;
 452     }
 453     reply->from   = format->from;
 454     reply->total  = format->size;
 455     reply->seqno  = format->seqno;
 456     reply->owner  = clipboard->owner;
 457
 458     if (!format->data && req->render)  /* try rendering it client-side */
 459     {
 460         if (format->from || clipboard->owner) clipboard->rendering++;
 461         return;
 462     }
 463
 464     if (req->cached && req->seqno == format->seqno) goto done;  /* client-side cache still valid */
 465
 466     if (format->size > get_reply_max_size())
 467     {
 468         set_error( STATUS_BUFFER_OVERFLOW );
 469         return;
 470     }
 471     set_reply_data( format->data, format->size );
 472
 473 done:
 474     if (!req->render) clipboard->rendering--;
 475 }
 476
 477
 478 /* retrieve a list of available formats */
 479 DECL_HANDLER(get_clipboard_formats)
 480 {
 481     struct clipboard *clipboard = get_process_clipboard();
 482
 483     if (!clipboard) return;
 484
 485     if (!req->format)
 486     {
 487         struct clip_format *format;
 488         unsigned int i = 0, *ptr;
 489         data_size_t size = clipboard->format_count * sizeof(unsigned int);
 490
 491         reply->count = clipboard->format_count;
 492         if (size <= get_reply_max_size())
 493         {
 494             if ((ptr = mem_alloc( size )))
 495             {
 496                 LIST_FOR_EACH_ENTRY( format, &clipboard->formats, struct clip_format, entry )
 497                     ptr[i++] = format->id;
 498                 assert( i == clipboard->format_count );
 499                 set_reply_data_ptr( ptr, size );
 500             }
 501         }
 502         else set_error( STATUS_BUFFER_TOO_SMALL );
 503     }
 504     else reply->count = (get_format( clipboard, req->format ) != NULL);  /* query a single format */
 505 }
 506
 507
 508 /* retrieve the next available format */
 509 DECL_HANDLER(enum_clipboard_formats)
 510 {
 511     struct list *ptr;
 512     struct clipboard *clipboard = get_process_clipboard();
 513
 514     if (!clipboard) return;
 515
 516     if (clipboard->open_thread != current)
 517     {
 518         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 519         return;
 520     }
 521
 522     ptr = list_head( &clipboard->formats );
 523     if (req->previous)
 524     {
 525         while (ptr && LIST_ENTRY( ptr, struct clip_format, entry )->id != req->previous)
 526             ptr = list_next( &clipboard->formats, ptr );
 527         if (ptr) ptr = list_next( &clipboard->formats, ptr );
 528     }
 529     if (ptr) reply->format = LIST_ENTRY( ptr, struct clip_format, entry )->id;
 530 }
 531
 532
 533 /* empty the clipboard and grab ownership */
 534 DECL_HANDLER(empty_clipboard)
 535 {
 536     struct clipboard *clipboard = get_process_clipboard();
 537
 538     if (!clipboard) return;
 539
 540     if (clipboard->open_thread != current)
 541     {
 542         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 543         return;
 544     }
 545
 546     free_clipboard_formats( clipboard );
 547     clipboard->owner = clipboard->open_win;
 548     clipboard->seqno++;
 549 }
 550
 551
 552 /* release ownership of the clipboard */
 553 DECL_HANDLER(release_clipboard)
 554 {
 555     struct clipboard *clipboard = get_process_clipboard();
 556     user_handle_t owner;
 557
 558     if (!clipboard) return;
 559
 560     if (!(owner = get_valid_window_handle( req->owner ))) return;
 561
 562     if (clipboard->owner == owner)
 563     {
 564         reply->viewer = release_clipboard( clipboard );
 565         reply->owner = clipboard->owner;
 566     }
 567     else set_error( STATUS_INVALID_OWNER );
 568 }
 569
 570
 571 /* get clipboard information */
 572 DECL_HANDLER(get_clipboard_info)
 573 {
 574     struct clipboard *clipboard = get_process_clipboard();
 575
 576     if (!clipboard) return;
 577
 578     reply->window = clipboard->open_win;
 579     reply->owner  = clipboard->owner;
 580     reply->viewer = clipboard->viewer;
 581     reply->seqno  = clipboard->seqno;
 582 }
 583
 584
 585 /* set the clipboard viewer window */
 586 DECL_HANDLER(set_clipboard_viewer)
 587 {
 588     struct clipboard *clipboard = get_process_clipboard();
 589     user_handle_t viewer = 0, previous = 0;
 590
 591     if (!clipboard) return;
 592     if (req->viewer && !(viewer = get_valid_window_handle( req->viewer ))) return;
 593     if (req->previous && !(previous = get_valid_window_handle( req->previous ))) return;
 594
 595     reply->old_viewer = clipboard->viewer;
 596     reply->owner      = clipboard->owner;
 597
 598     if (!previous || clipboard->viewer == previous)
 599         clipboard->viewer = viewer;
 600     else
 601         set_error( STATUS_PENDING );  /* need to send message instead */
 602 }
 603
 604
 605 /* add a clipboard listener window */
 606 DECL_HANDLER(add_clipboard_listener)
 607 {
 608     struct clipboard *clipboard = get_process_clipboard();
 609     user_handle_t win;
 610
 611     if (!clipboard) return;
 612     if (!(win = get_valid_window_handle( req->window ))) return;
 613
 614     add_listener( clipboard, win );
 615 }
 616
 617
 618 /* remove a clipboard listener window */
 619 DECL_HANDLER(remove_clipboard_listener)
 620 {
 621     struct clipboard *clipboard = get_process_clipboard();
 622     user_handle_t win;
 623
 624     if (!clipboard) return;
 625     if (!(win = get_valid_window_handle( req->window ))) return;
 626
 627     if (!remove_listener( clipboard, win )) set_error( STATUS_INVALID_PARAMETER );
 628 }