server/clipboard.c

   1 /*
   2  * Server-side clipboard management
   3  *
   4  * Copyright (C) 2002 Ulrich Czekalla
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "request.h"
  32 #include "object.h"
  33 #include "file.h"
  34 #include "process.h"
  35 #include "user.h"
  36 #include "winuser.h"
  37 #include "winternl.h"
  38
  39 struct clipboard
  40 {
  41     struct object  obj;              /* object header */
  42     struct thread *open_thread;      /* thread id that has clipboard open */
  43     user_handle_t  open_win;         /* window that has clipboard open */
  44     struct thread *owner_thread;     /* thread id that owns the clipboard */
  45     user_handle_t  owner_win;        /* window that owns the clipboard data */
  46     user_handle_t  viewer;           /* first window in clipboard viewer list */
  47     unsigned int   seqno;            /* clipboard change sequence number */
  48     unsigned int   open_seqno;       /* sequence number at open time */
  49     timeout_t      seqno_timestamp;  /* time stamp of last seqno increment */
  50     unsigned int   listen_size;      /* size of listeners array */
  51     unsigned int   listen_count;     /* count of listeners */
  52     user_handle_t *listeners;        /* array of listener windows */
  53 };
  54
  55 static void clipboard_dump( struct object *obj, int verbose );
  56 static void clipboard_destroy( struct object *obj );
  57
  58 static const struct object_ops clipboard_ops =
  59 {
  60     sizeof(struct clipboard),     /* size */
  61     clipboard_dump,               /* dump */
  62     no_get_type,                  /* get_type */
  63     no_add_queue,                 /* add_queue */
  64     NULL,                         /* remove_queue */
  65     NULL,                         /* signaled */
  66     NULL,                         /* satisfied */
  67     no_signal,                    /* signal */
  68     no_get_fd,                    /* get_fd */
  69     no_map_access,                /* map_access */
  70     default_get_sd,               /* get_sd */
  71     default_set_sd,               /* set_sd */
  72     no_lookup_name,               /* lookup_name */
  73     no_link_name,                 /* link_name */
  74     NULL,                         /* unlink_name */
  75     no_open_file,                 /* open_file */
  76     no_close_handle,              /* close_handle */
  77     clipboard_destroy             /* destroy */
  78 };
  79
  80
  81 #define MINUPDATELAPSE (2 * TICKS_PER_SEC)
  82
  83 /* dump a clipboard object */
  84 static void clipboard_dump( struct object *obj, int verbose )
  85 {
  86     struct clipboard *clipboard = (struct clipboard *)obj;
  87
  88     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
  89              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
  90              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
  91 }
  92
  93 static void clipboard_destroy( struct object *obj )
  94 {
  95     struct clipboard *clipboard = (struct clipboard *)obj;
  96
  97     free( clipboard->listeners );
  98 }
  99
 100 /* retrieve the clipboard info for the current process, allocating it if needed */
 101 static struct clipboard *get_process_clipboard(void)
 102 {
 103     struct clipboard *clipboard;
 104     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
 105
 106     if (!winstation) return NULL;
 107
 108     if (!(clipboard = winstation->clipboard))
 109     {
 110         if ((clipboard = alloc_object( &clipboard_ops )))
 111         {
 112             clipboard->open_thread = NULL;
 113             clipboard->open_win = 0;
 114             clipboard->owner_thread = NULL;
 115             clipboard->owner_win = 0;
 116             clipboard->viewer = 0;
 117             clipboard->seqno = 0;
 118             clipboard->seqno_timestamp = 0;
 119             clipboard->listen_size = 0;
 120             clipboard->listen_count = 0;
 121             clipboard->listeners = NULL;
 122             winstation->clipboard = clipboard;
 123         }
 124     }
 125     release_object( winstation );
 126     return clipboard;
 127 }
 128
 129 /* add a clipboard listener */
 130 static void add_listener( struct clipboard *clipboard, user_handle_t window )
 131 {
 132     unsigned int i;
 133
 134     for (i = 0; i < clipboard->listen_count; i++)
 135     {
 136         if (clipboard->listeners[i] != window) continue;
 137         set_error( STATUS_INVALID_PARAMETER );  /* already set */
 138         return;
 139     }
 140     if (clipboard->listen_size == clipboard->listen_count)
 141     {
 142         unsigned int new_size = max( 8, clipboard->listen_size * 2 );
 143         user_handle_t *new = realloc( clipboard->listeners, new_size * sizeof(*new) );
 144         if (!new)
 145         {
 146             set_error( STATUS_NO_MEMORY );
 147             return;
 148         }
 149         clipboard->listeners = new;
 150         clipboard->listen_size = new_size;
 151     }
 152     clipboard->listeners[clipboard->listen_count++] = window;
 153 }
 154
 155 /* remove a clipboard listener */
 156 static int remove_listener( struct clipboard *clipboard, user_handle_t window )
 157 {
 158     unsigned int i;
 159
 160     for (i = 0; i < clipboard->listen_count; i++)
 161     {
 162         if (clipboard->listeners[i] != window) continue;
 163         memmove( clipboard->listeners + i, clipboard->listeners + i + 1,
 164                  (clipboard->listen_count - i - 1) * sizeof(*clipboard->listeners) );
 165         clipboard->listen_count--;
 166         return 1;
 167     }
 168     return 0;
 169 }
 170
 171 /* close the clipboard, and return the viewer window that should be notified if any */
 172 static user_handle_t close_clipboard( struct clipboard *clipboard )
 173 {
 174     unsigned int i;
 175
 176     clipboard->open_win = 0;
 177     clipboard->open_thread = NULL;
 178
 179     if (clipboard->seqno == clipboard->open_seqno) return 0;  /* unchanged */
 180
 181     for (i = 0; i < clipboard->listen_count; i++)
 182         post_message( clipboard->listeners[i], WM_CLIPBOARDUPDATE, 0, 0 );
 183     return clipboard->viewer;
 184 }
 185
 186 /* release the clipboard owner, and return the viewer window that should be notified if any */
 187 static user_handle_t release_clipboard( struct clipboard *clipboard )
 188 {
 189     clipboard->owner_win = 0;
 190     clipboard->owner_thread = NULL;
 191     /* FIXME: free delay-rendered formats if any and notify listeners */
 192     return 0;
 193 }
 194
 195 /* cleanup clipboard information upon window destruction */
 196 void cleanup_clipboard_window( struct desktop *desktop, user_handle_t window )
 197 {
 198     struct clipboard *clipboard = desktop->winstation->clipboard;
 199
 200     if (!clipboard) return;
 201
 202     remove_listener( clipboard, window );
 203     if (clipboard->viewer == window) clipboard->viewer = 0;
 204     if (clipboard->owner_win == window) release_clipboard( clipboard );
 205     if (clipboard->open_win == window)
 206     {
 207         user_handle_t viewer = close_clipboard( clipboard );
 208         if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner_win, 0 );
 209     }
 210 }
 211
 212 /* Called when thread terminates to allow release of clipboard */
 213 void cleanup_clipboard_thread(struct thread *thread)
 214 {
 215     struct clipboard *clipboard;
 216     struct winstation *winstation;
 217
 218     if (!thread->process->winstation) return;
 219     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
 220
 221     if ((clipboard = winstation->clipboard))
 222     {
 223         if (thread == clipboard->owner_thread) clipboard->owner_thread = NULL;
 224         if (thread == clipboard->open_thread)
 225         {
 226             user_handle_t viewer = close_clipboard( clipboard );
 227             if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner_win, 0 );
 228         }
 229     }
 230     release_object( winstation );
 231 }
 232
 233 static int release_clipboard_owner( struct clipboard *clipboard, user_handle_t win )
 234 {
 235     if ((clipboard->open_thread && clipboard->open_thread->process != current->process) ||
 236         (win && clipboard->owner_win != get_user_full_handle( win )))
 237     {
 238         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 239         return 0;
 240     }
 241     clipboard->owner_win = 0;
 242     clipboard->owner_thread = NULL;
 243     return 1;
 244 }
 245
 246
 247 static int get_seqno( struct clipboard *clipboard )
 248 {
 249     if (!clipboard->owner_thread && (current_time - clipboard->seqno_timestamp > MINUPDATELAPSE))
 250     {
 251         clipboard->seqno_timestamp = current_time;
 252         clipboard->seqno++;
 253     }
 254     return clipboard->seqno;
 255 }
 256
 257
 258 /* open the clipboard */
 259 DECL_HANDLER(open_clipboard)
 260 {
 261     struct clipboard *clipboard = get_process_clipboard();
 262     user_handle_t win = 0;
 263
 264     if (!clipboard) return;
 265     if (req->window && !(win = get_valid_window_handle( req->window ))) return;
 266
 267     if (clipboard->open_thread && clipboard->open_win != win)
 268     {
 269         set_error( STATUS_INVALID_LOCK_SEQUENCE );
 270         return;
 271     }
 272
 273     if (!clipboard->open_thread) clipboard->open_seqno = clipboard->seqno; /* first open */
 274     clipboard->open_win = win;
 275     clipboard->open_thread = current;
 276
 277     reply->owner = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 278 }
 279
 280
 281 /* close the clipboard */
 282 DECL_HANDLER(close_clipboard)
 283 {
 284     struct clipboard *clipboard = get_process_clipboard();
 285
 286     if (!clipboard) return;
 287
 288     if (clipboard->open_thread != current)
 289     {
 290         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 291         return;
 292     }
 293     if (req->changed) clipboard->seqno++;
 294
 295     reply->viewer = close_clipboard( clipboard );
 296     reply->owner  = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 297 }
 298
 299
 300 DECL_HANDLER(set_clipboard_info)
 301 {
 302     struct clipboard *clipboard = get_process_clipboard();
 303
 304     if (!clipboard) return;
 305
 306     reply->old_clipboard = clipboard->open_win;
 307     reply->old_owner     = clipboard->owner_win;
 308     reply->old_viewer    = clipboard->viewer;
 309
 310     if (req->flags & SET_CB_RELOWNER)
 311     {
 312         if (!release_clipboard_owner( clipboard, req->owner )) return;
 313     }
 314
 315     if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
 316
 317     reply->seqno = get_seqno( clipboard );
 318
 319     if (clipboard->open_thread) reply->flags |= CB_OPEN_ANY;
 320     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
 321     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
 322     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
 323         reply->flags |= CB_PROCESS;
 324 }
 325
 326
 327 /* empty the clipboard and grab ownership */
 328 DECL_HANDLER(empty_clipboard)
 329 {
 330     struct clipboard *clipboard = get_process_clipboard();
 331
 332     if (!clipboard) return;
 333
 334     if (clipboard->open_thread != current)
 335     {
 336         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 337         return;
 338     }
 339     clipboard->owner_win = clipboard->open_win;
 340     clipboard->owner_thread = clipboard->open_thread;
 341     clipboard->seqno++;
 342 }
 343
 344
 345 /* release ownership of the clipboard */
 346 DECL_HANDLER(release_clipboard)
 347 {
 348     struct clipboard *clipboard = get_process_clipboard();
 349     user_handle_t owner;
 350
 351     if (!clipboard) return;
 352
 353     if (!(owner = get_valid_window_handle( req->owner ))) return;
 354
 355     if (clipboard->owner_win == owner)
 356         reply->viewer = release_clipboard( clipboard );
 357     else
 358         set_error( STATUS_INVALID_OWNER );
 359 }
 360
 361
 362 /* get clipboard information */
 363 DECL_HANDLER(get_clipboard_info)
 364 {
 365     struct clipboard *clipboard = get_process_clipboard();
 366
 367     if (!clipboard) return;
 368
 369     reply->window = clipboard->open_win;
 370     reply->owner  = clipboard->owner_win;
 371     reply->viewer = clipboard->viewer;
 372     reply->seqno  = get_seqno( clipboard );
 373 }
 374
 375
 376 /* set the clipboard viewer window */
 377 DECL_HANDLER(set_clipboard_viewer)
 378 {
 379     struct clipboard *clipboard = get_process_clipboard();
 380     user_handle_t viewer = 0, previous = 0;
 381
 382     if (!clipboard) return;
 383     if (req->viewer && !(viewer = get_valid_window_handle( req->viewer ))) return;
 384     if (req->previous && !(previous = get_valid_window_handle( req->previous ))) return;
 385
 386     reply->old_viewer = clipboard->viewer;
 387     reply->owner      = clipboard->owner_win;
 388
 389     if (!previous || clipboard->viewer == previous)
 390         clipboard->viewer = viewer;
 391     else
 392         set_error( STATUS_PENDING );  /* need to send message instead */
 393 }
 394
 395
 396 /* add a clipboard listener window */
 397 DECL_HANDLER(add_clipboard_listener)
 398 {
 399     struct clipboard *clipboard = get_process_clipboard();
 400     user_handle_t win;
 401
 402     if (!clipboard) return;
 403     if (!(win = get_valid_window_handle( req->window ))) return;
 404
 405     add_listener( clipboard, win );
 406 }
 407
 408
 409 /* remove a clipboard listener window */
 410 DECL_HANDLER(remove_clipboard_listener)
 411 {
 412     struct clipboard *clipboard = get_process_clipboard();
 413     user_handle_t win;
 414
 415     if (!clipboard) return;
 416     if (!(win = get_valid_window_handle( req->window ))) return;
 417
 418     if (!remove_listener( clipboard, win )) set_error( STATUS_INVALID_PARAMETER );
 419 }