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 };
  50
  51 static void clipboard_dump( struct object *obj, int verbose );
  52
  53 static const struct object_ops clipboard_ops =
  54 {
  55     sizeof(struct clipboard),     /* size */
  56     clipboard_dump,               /* dump */
  57     no_get_type,                  /* get_type */
  58     no_add_queue,                 /* add_queue */
  59     NULL,                         /* remove_queue */
  60     NULL,                         /* signaled */
  61     NULL,                         /* satisfied */
  62     no_signal,                    /* signal */
  63     no_get_fd,                    /* get_fd */
  64     no_map_access,                /* map_access */
  65     default_get_sd,               /* get_sd */
  66     default_set_sd,               /* set_sd */
  67     no_lookup_name,               /* lookup_name */
  68     no_link_name,                 /* link_name */
  69     NULL,                         /* unlink_name */
  70     no_open_file,                 /* open_file */
  71     no_close_handle,              /* close_handle */
  72     no_destroy                    /* destroy */
  73 };
  74
  75
  76 #define MINUPDATELAPSE (2 * TICKS_PER_SEC)
  77
  78 /* dump a clipboard object */
  79 static void clipboard_dump( struct object *obj, int verbose )
  80 {
  81     struct clipboard *clipboard = (struct clipboard *)obj;
  82
  83     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
  84              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
  85              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
  86 }
  87
  88 /* retrieve the clipboard info for the current process, allocating it if needed */
  89 static struct clipboard *get_process_clipboard(void)
  90 {
  91     struct clipboard *clipboard;
  92     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
  93
  94     if (!winstation) return NULL;
  95
  96     if (!(clipboard = winstation->clipboard))
  97     {
  98         if ((clipboard = alloc_object( &clipboard_ops )))
  99         {
 100             clipboard->open_thread = NULL;
 101             clipboard->open_win = 0;
 102             clipboard->owner_thread = NULL;
 103             clipboard->owner_win = 0;
 104             clipboard->viewer = 0;
 105             clipboard->seqno = 0;
 106             clipboard->seqno_timestamp = 0;
 107             winstation->clipboard = clipboard;
 108         }
 109     }
 110     release_object( winstation );
 111     return clipboard;
 112 }
 113
 114 /* cleanup clipboard information upon window destruction */
 115 void cleanup_clipboard_window( struct desktop *desktop, user_handle_t window )
 116 {
 117     struct clipboard *clipboard = desktop->winstation->clipboard;
 118
 119     if (!clipboard) return;
 120
 121     if (clipboard->open_win == window)
 122     {
 123         clipboard->open_win = 0;
 124         clipboard->open_thread = NULL;
 125     }
 126     if (clipboard->owner_win == window)
 127     {
 128         clipboard->owner_win = 0;
 129         clipboard->owner_thread = NULL;
 130     }
 131     if (clipboard->viewer == window) clipboard->viewer = 0;
 132 }
 133
 134 /* Called when thread terminates to allow release of clipboard */
 135 void cleanup_clipboard_thread(struct thread *thread)
 136 {
 137     struct clipboard *clipboard;
 138     struct winstation *winstation;
 139
 140     if (!thread->process->winstation) return;
 141     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
 142
 143     if ((clipboard = winstation->clipboard))
 144     {
 145         if (thread == clipboard->open_thread)
 146         {
 147             clipboard->open_win = 0;
 148             clipboard->open_thread = NULL;
 149         }
 150         if (thread == clipboard->owner_thread)
 151         {
 152             clipboard->owner_win = 0;
 153             clipboard->owner_thread = NULL;
 154         }
 155     }
 156     release_object( winstation );
 157 }
 158
 159 static int release_clipboard_owner( struct clipboard *clipboard, user_handle_t win )
 160 {
 161     if ((clipboard->open_thread && clipboard->open_thread->process != current->process) ||
 162         (win && clipboard->owner_win != get_user_full_handle( win )))
 163     {
 164         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 165         return 0;
 166     }
 167     clipboard->owner_win = 0;
 168     clipboard->owner_thread = NULL;
 169     return 1;
 170 }
 171
 172
 173 static int get_seqno( struct clipboard *clipboard )
 174 {
 175     if (!clipboard->owner_thread && (current_time - clipboard->seqno_timestamp > MINUPDATELAPSE))
 176     {
 177         clipboard->seqno_timestamp = current_time;
 178         clipboard->seqno++;
 179     }
 180     return clipboard->seqno;
 181 }
 182
 183
 184 /* open the clipboard */
 185 DECL_HANDLER(open_clipboard)
 186 {
 187     struct clipboard *clipboard = get_process_clipboard();
 188     user_handle_t win = req->window;
 189
 190     if (!clipboard) return;
 191
 192     if (win && !get_user_object_handle( &win, USER_WINDOW ))
 193     {
 194         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 195         return;
 196     }
 197     if (clipboard->open_thread && clipboard->open_win != win)
 198     {
 199         set_error( STATUS_INVALID_LOCK_SEQUENCE );
 200         return;
 201     }
 202     clipboard->open_win = win;
 203     clipboard->open_thread = current;
 204
 205     reply->owner = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 206 }
 207
 208
 209 /* close the clipboard */
 210 DECL_HANDLER(close_clipboard)
 211 {
 212     struct clipboard *clipboard = get_process_clipboard();
 213
 214     if (!clipboard) return;
 215
 216     if (clipboard->open_thread != current)
 217     {
 218         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 219         return;
 220     }
 221     if (req->changed) clipboard->seqno++;
 222     clipboard->open_thread = NULL;
 223     clipboard->open_win = 0;
 224
 225     reply->viewer = clipboard->viewer;
 226     reply->owner  = (clipboard->owner_thread && clipboard->owner_thread->process == current->process);
 227 }
 228
 229
 230 DECL_HANDLER(set_clipboard_info)
 231 {
 232     struct clipboard *clipboard = get_process_clipboard();
 233
 234     if (!clipboard) return;
 235
 236     reply->old_clipboard = clipboard->open_win;
 237     reply->old_owner     = clipboard->owner_win;
 238     reply->old_viewer    = clipboard->viewer;
 239
 240     if (req->flags & SET_CB_RELOWNER)
 241     {
 242         if (!release_clipboard_owner( clipboard, req->owner )) return;
 243     }
 244
 245     if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
 246
 247     reply->seqno = get_seqno( clipboard );
 248
 249     if (clipboard->open_thread) reply->flags |= CB_OPEN_ANY;
 250     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
 251     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
 252     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
 253         reply->flags |= CB_PROCESS;
 254 }
 255
 256
 257 /* empty the clipboard and grab ownership */
 258 DECL_HANDLER(empty_clipboard)
 259 {
 260     struct clipboard *clipboard = get_process_clipboard();
 261
 262     if (!clipboard) return;
 263
 264     if (clipboard->open_thread != current)
 265     {
 266         set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
 267         return;
 268     }
 269     clipboard->owner_win = clipboard->open_win;
 270     clipboard->owner_thread = clipboard->open_thread;
 271     clipboard->seqno++;
 272 }
 273
 274
 275 /* Get clipboard information */
 276 DECL_HANDLER(get_clipboard_info)
 277 {
 278     struct clipboard *clipboard = get_process_clipboard();
 279
 280     if (!clipboard) return;
 281
 282     reply->window = clipboard->open_win;
 283     reply->owner  = clipboard->owner_win;
 284     reply->viewer = clipboard->viewer;
 285     reply->seqno  = get_seqno( clipboard );
 286 }
 287
 288
 289 /* set the clipboard viewer window */
 290 DECL_HANDLER(set_clipboard_viewer)
 291 {
 292     struct clipboard *clipboard = get_process_clipboard();
 293     user_handle_t viewer = req->viewer;
 294     user_handle_t previous = req->previous;
 295
 296     if (!clipboard) return;
 297
 298     if (viewer && !get_user_object_handle( &viewer, USER_WINDOW ))
 299     {
 300         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 301         return;
 302     }
 303     if (previous && !get_user_object_handle( &previous, USER_WINDOW ))
 304     {
 305         set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
 306         return;
 307     }
 308
 309     reply->old_viewer = clipboard->viewer;
 310     reply->owner      = clipboard->owner_win;
 311
 312     if (!previous || clipboard->viewer == previous)
 313         clipboard->viewer = viewer;
 314     else
 315         set_error( STATUS_PENDING );  /* need to send message instead */
 316 }