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     timeout_t      seqno_timestamp;  /* time stamp of last seqno increment */
  49     unsigned int   listen_size;      /* size of listeners array */
  50     unsigned int   listen_count;     /* count of listeners */
  51     user_handle_t *listeners;        /* array of listener windows */
  52 };
  53
  54 static void clipboard_dump( struct object *obj, int verbose );
  55 static void clipboard_destroy( struct object *obj );
  56
  57 static const struct object_ops clipboard_ops =
  58 {
  59     sizeof(struct clipboard),     /* size */
  60     clipboard_dump,               /* dump */
  61     no_get_type,                  /* get_type */
  62     no_add_queue,                 /* add_queue */
  63     NULL,                         /* remove_queue */
  64     NULL,                         /* signaled */
  65     NULL,                         /* satisfied */
  66     no_signal,                    /* signal */
  67     no_get_fd,                    /* get_fd */
  68     no_map_access,                /* map_access */
  69     default_get_sd,               /* get_sd */
  70     default_set_sd,               /* set_sd */
  71     no_lookup_name,               /* lookup_name */
  72     no_link_name,                 /* link_name */
  73     NULL,                         /* unlink_name */
  74     no_open_file,                 /* open_file */
  75     no_close_handle,              /* close_handle */
  76     clipboard_destroy             /* destroy */
  77 };
  78
  79
  80 #define MINUPDATELAPSE (2 * TICKS_PER_SEC)
  81
  82 /* dump a clipboard object */
  83 static void clipboard_dump( struct object *obj, int verbose )
  84 {
  85     struct clipboard *clipboard = (struct clipboard *)obj;
  86
  87     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
  88              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
  89              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
  90 }
  91
  92 static void clipboard_destroy( struct object *obj )
  93 {
  94     struct clipboard *clipboard = (struct clipboard *)obj;
  95
  96     free( clipboard->listeners );
  97 }
  98
  99 /* retrieve the clipboard info for the current process, allocating it if needed */
 100 static struct clipboard *get_process_clipboard(void)
 101 {
 102     struct clipboard *clipboard;
 103     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
 104
 105     if (!winstation) return NULL;
 106
 107     if (!(clipboard = winstation->clipboard))
 108     {
 109         if ((clipboard = alloc_object( &clipboard_ops )))
 110         {
 111             clipboard->open_thread = NULL;
 112             clipboard->open_win = 0;
 113             clipboard->owner_thread = NULL;
 114             clipboard->owner_win = 0;
 115             clipboard->viewer = 0;
 116             clipboard->seqno = 0;
 117             clipboard->seqno_timestamp = 0;
 118             clipboard->listen_size = 0;
 119             clipboard->listen_count = 0;
 120             clipboard->listeners = NULL;
 121             winstation->clipboard = clipboard;
 122         }
 123     }
 124     release_object( winstation );
 125     return clipboard;
 126 }
 127
 128 /* add a clipboard listener */
 129 static void add_listener( struct clipboard *clipboard, user_handle_t window )
 130 {
 131     unsigned int i;
 132
 133     for (i = 0; i < clipboard->listen_count; i++)
 134     {
 135         if (clipboard->listeners[i] != window) continue;
 136         set_error( STATUS_INVALID_PARAMETER );  /* already set */
 137         return;
 138     }
 139     if (clipboard->listen_size == clipboard->listen_count)
 140     {
 141         unsigned int new_size = max( 8, clipboard->listen_size * 2 );
 142         user_handle_t *new = realloc( clipboard->listeners, new_size * sizeof(*new) );
 143         if (!new)
 144         {
 145             set_error( STATUS_NO_MEMORY );
 146             return;
 147         }
 148         clipboard->listeners = new;
 149         clipboard->listen_size = new_size;
 150     }
 151     clipboard->listeners[clipboard->listen_count++] = window;
 152 }
 153
 154 /* remove a clipboard listener */
 155 static int remove_listener( struct clipboard *clipboard, user_handle_t window )
 156 {
 157     unsigned int i;
 158
 159     for (i = 0; i < clipboard->listen_count; i++)
 160     {
 161         if (clipboard->listeners[i] != window) continue;
 162         memmove( clipboard->listeners + i, clipboard->listeners + i + 1,
 163                  (clipboard->listen_count - i - 1) * sizeof(*clipboard->listeners) );
 164         clipboard->listen_count--;
 165         return 1;
 166     }
 167     return 0;
 168 }
 169
 170 /* cleanup clipboard information upon window destruction */
 171 void cleanup_clipboard_window( struct desktop *desktop, user_handle_t window )
 172 {
 173     struct clipboard *clipboard = desktop->winstation->clipboard;
 174
 175     if (!clipboard) return;
 176
 177     if (clipboard->open_win == window)
 178     {
 179         clipboard->open_win = 0;
 180         clipboard->open_thread = NULL;
 181     }
 182     if (clipboard->owner_win == window)
 183     {
 184         clipboard->owner_win = 0;
 185         clipboard->owner_thread = NULL;
 186     }
 187     if (clipboard->viewer == window) clipboard->viewer = 0;
 188     remove_listener( clipboard, window );
 189 }
 190
 191 /* Called when thread terminates to allow release of clipboard */
 192 void cleanup_clipboard_thread(struct thread *thread)
 193 {
 194     struct clipboard *clipboard;
 195     struct winstation *winstation;
 196
 197     if (!thread->process->winstation) return;
 198     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
 199
 200     if ((clipboard = winstation->clipboard))
 201     {
 202         if (thread == clipboard->open_thread)
 203         {
 204             clipboard->open_win = 0;
 205             clipboard->open_thread = NULL;
 206         }
 207         if (thread == clipboard->owner_thread)
 208         {
 209             clipboard->owner_win = 0;
 210             clipboard->owner_thread = NULL;
 211         }
 212     }
 213     release_object( winstation );
 214 }
 215
 216 static int release_clipboard_owner( struct clipboard *clipboard, user_handle_t win )
 217 {
 218     if ((clipboard->open_thread && clipboard->open_thread->process != current->process) ||
 219         (win && clipboard->owner_win != get_user_full_handle( win )))
 220     {
 221         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 222         return 0;
 223     }
 224     clipboard->owner_win = 0;
 225     clipboard->owner_thread = NULL;
 226     return 1;
 227 }
 228
 229
 230 static int get_seqno( struct clipboard *clipboard )
 231 {
 232     if (!clipboard->owner_thread && (current_time - clipboard->seqno_timestamp > MINUPDATELAPSE))
 233     {
 234         clipboard->seqno_timestamp = current_time;
 235         clipboard->seqno++;
 236     }
 237     return clipboard->seqno;
 238 }
 239
 240
 241 /* open the clipboard */
 242 DECL_HANDLER(open_clipboard)
 243 {
 244     struct clipboard *clipboard = get_process_clipboard();
 245     user_handle_t win = req->window;
 246
 247     if (!clipboard) return;
 248
 249     if (win && !get_user_object_handle( &win, USER_WINDOW ))
 250     {
 251         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 252         return;
 253     }
 254     if (clipboard->open_thread && clipboard->open_win != win)
 255     {
 256         set_error( STATUS_INVALID_LOCK_SEQUENCE );
 257         return;
 258     }
 259     clipboard->open_win = win;
 260     clipboard->open_thread = current;
 261
 262     reply->owner = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 263 }
 264
 265
 266 /* close the clipboard */
 267 DECL_HANDLER(close_clipboard)
 268 {
 269     struct clipboard *clipboard = get_process_clipboard();
 270
 271     if (!clipboard) return;
 272
 273     if (clipboard->open_thread != current)
 274     {
 275         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 276         return;
 277     }
 278     if (req->changed) clipboard->seqno++;
 279     clipboard->open_thread = NULL;
 280     clipboard->open_win = 0;
 281
 282     reply->viewer = clipboard->viewer;
 283     reply->owner  = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 284 }
 285
 286
 287 DECL_HANDLER(set_clipboard_info)
 288 {
 289     struct clipboard *clipboard = get_process_clipboard();
 290
 291     if (!clipboard) return;
 292
 293     reply->old_clipboard = clipboard->open_win;
 294     reply->old_owner     = clipboard->owner_win;
 295     reply->old_viewer    = clipboard->viewer;
 296
 297     if (req->flags & SET_CB_RELOWNER)
 298     {
 299         if (!release_clipboard_owner( clipboard, req->owner )) return;
 300     }
 301
 302     if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
 303
 304     reply->seqno = get_seqno( clipboard );
 305
 306     if (clipboard->open_thread) reply->flags |= CB_OPEN_ANY;
 307     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
 308     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
 309     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
 310         reply->flags |= CB_PROCESS;
 311 }
 312
 313
 314 /* empty the clipboard and grab ownership */
 315 DECL_HANDLER(empty_clipboard)
 316 {
 317     struct clipboard *clipboard = get_process_clipboard();
 318
 319     if (!clipboard) return;
 320
 321     if (clipboard->open_thread != current)
 322     {
 323         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 324         return;
 325     }
 326     clipboard->owner_win = clipboard->open_win;
 327     clipboard->owner_thread = clipboard->open_thread;
 328     clipboard->seqno++;
 329 }
 330
 331
 332 /* Get clipboard information */
 333 DECL_HANDLER(get_clipboard_info)
 334 {
 335     struct clipboard *clipboard = get_process_clipboard();
 336
 337     if (!clipboard) return;
 338
 339     reply->window = clipboard->open_win;
 340     reply->owner  = clipboard->owner_win;
 341     reply->viewer = clipboard->viewer;
 342     reply->seqno  = get_seqno( clipboard );
 343 }
 344
 345
 346 /* set the clipboard viewer window */
 347 DECL_HANDLER(set_clipboard_viewer)
 348 {
 349     struct clipboard *clipboard = get_process_clipboard();
 350     user_handle_t viewer = req->viewer;
 351     user_handle_t previous = req->previous;
 352
 353     if (!clipboard) return;
 354
 355     if (viewer && !get_user_object_handle( &viewer, USER_WINDOW ))
 356     {
 357         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 358         return;
 359     }
 360     if (previous && !get_user_object_handle( &previous, USER_WINDOW ))
 361     {
 362         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 363         return;
 364     }
 365
 366     reply->old_viewer = clipboard->viewer;
 367     reply->owner      = clipboard->owner_win;
 368
 369     if (!previous || clipboard->viewer == previous)
 370         clipboard->viewer = viewer;
 371     else
 372         set_error( STATUS_PENDING );  /* need to send message instead */
 373 }
 374
 375
 376 /* add a clipboard listener window */
 377 DECL_HANDLER(add_clipboard_listener)
 378 {
 379     struct clipboard *clipboard = get_process_clipboard();
 380     user_handle_t win = req->window;
 381
 382     if (!clipboard) return;
 383
 384     if (!get_user_object_handle( &win, USER_WINDOW ))
 385     {
 386         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 387         return;
 388     }
 389
 390     add_listener( clipboard, win );
 391 }
 392
 393
 394 /* remove a clipboard listener window */
 395 DECL_HANDLER(remove_clipboard_listener)
 396 {
 397     struct clipboard *clipboard = get_process_clipboard();
 398     user_handle_t win = req->window;
 399
 400     if (!clipboard) return;
 401
 402     if (!get_user_object_handle( &win, USER_WINDOW ))
 403     {
 404         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 405         return;
 406     }
 407
 408     if (!remove_listener( clipboard, win )) set_error( STATUS_INVALID_PARAMETER );
 409 }