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 "process.h"
  34 #include "user.h"
  35 #include "winuser.h"
  36 #include "winternl.h"
  37
  38 struct clipboard
  39 {
  40     struct object  obj;              /* object header */
  41     struct thread *open_thread;      /* thread id that has clipboard open */
  42     user_handle_t  open_win;         /* window that has clipboard open */
  43     struct thread *owner_thread;     /* thread id that owns the clipboard */
  44     user_handle_t  owner_win;        /* window that owns the clipboard data */
  45     user_handle_t  viewer;           /* first window in clipboard viewer list */
  46     unsigned int   seqno;            /* clipboard change sequence number */
  47     time_t         seqno_timestamp;  /* time stamp of last seqno increment */
  48 };
  49
  50 static void clipboard_dump( struct object *obj, int verbose );
  51
  52 static const struct object_ops clipboard_ops =
  53 {
  54     sizeof(struct clipboard),     /* size */
  55     clipboard_dump,               /* dump */
  56     no_get_type,                  /* get_type */
  57     no_add_queue,                 /* add_queue */
  58     NULL,                         /* remove_queue */
  59     NULL,                         /* signaled */
  60     NULL,                         /* satisfied */
  61     no_signal,                    /* signal */
  62     no_get_fd,                    /* get_fd */
  63     no_map_access,                /* map_access */
  64     default_get_sd,               /* get_sd */
  65     default_set_sd,               /* set_sd */
  66     no_lookup_name,               /* lookup_name */
  67     no_open_file,                 /* open_file */
  68     no_close_handle,              /* close_handle */
  69     no_destroy                    /* destroy */
  70 };
  71
  72
  73 #define MINUPDATELAPSE 2
  74
  75 /* dump a clipboard object */
  76 static void clipboard_dump( struct object *obj, int verbose )
  77 {
  78     struct clipboard *clipboard = (struct clipboard *)obj;
  79
  80     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
  81              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
  82              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
  83 }
  84
  85 /* retrieve the clipboard info for the current process, allocating it if needed */
  86 static struct clipboard *get_process_clipboard(void)
  87 {
  88     struct clipboard *clipboard;
  89     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
  90
  91     if (!winstation) return NULL;
  92
  93     if (!(clipboard = winstation->clipboard))
  94     {
  95         if ((clipboard = alloc_object( &clipboard_ops )))
  96         {
  97             clipboard->open_thread = NULL;
  98             clipboard->open_win = 0;
  99             clipboard->owner_thread = NULL;
 100             clipboard->owner_win = 0;
 101             clipboard->viewer = 0;
 102             clipboard->seqno = 0;
 103             clipboard->seqno_timestamp = 0;
 104             winstation->clipboard = clipboard;
 105         }
 106     }
 107     release_object( winstation );
 108     return clipboard;
 109 }
 110
 111
 112 /* Called when thread terminates to allow release of clipboard */
 113 void cleanup_clipboard_thread(struct thread *thread)
 114 {
 115     struct clipboard *clipboard;
 116     struct winstation *winstation;
 117
 118     if (!thread->process->winstation) return;
 119     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
 120
 121     if ((clipboard = winstation->clipboard))
 122     {
 123         if (thread == clipboard->open_thread)
 124         {
 125             clipboard->open_win = 0;
 126             clipboard->open_thread = NULL;
 127         }
 128         if (thread == clipboard->owner_thread)
 129         {
 130             clipboard->owner_win = 0;
 131             clipboard->owner_thread = NULL;
 132         }
 133     }
 134     release_object( winstation );
 135 }
 136
 137 static int set_clipboard_window( struct clipboard *clipboard, user_handle_t win, int clear )
 138 {
 139     if (clipboard->open_thread && clipboard->open_thread != current)
 140     {
 141         set_error(STATUS_WAS_LOCKED);
 142         return 0;
 143     }
 144     else if (!clear)
 145     {
 146         clipboard->open_win = win;
 147         clipboard->open_thread = current;
 148     }
 149     else
 150     {
 151         clipboard->open_thread = NULL;
 152         clipboard->open_win = 0;
 153     }
 154     return 1;
 155 }
 156
 157
 158 static int set_clipboard_owner( struct clipboard *clipboard, user_handle_t win, int clear )
 159 {
 160     if (clipboard->open_thread && clipboard->open_thread->process != current->process)
 161     {
 162         set_error(STATUS_WAS_LOCKED);
 163         return 0;
 164     }
 165     else if (!clear)
 166     {
 167         clipboard->owner_win = win;
 168         clipboard->owner_thread = current;
 169     }
 170     else
 171     {
 172         clipboard->owner_win = 0;
 173         clipboard->owner_thread = NULL;
 174     }
 175     return 1;
 176 }
 177
 178
 179 static int get_seqno( struct clipboard *clipboard )
 180 {
 181     time_t tm = time(NULL);
 182
 183     if (!clipboard->owner_thread && (tm > (clipboard->seqno_timestamp + MINUPDATELAPSE)))
 184     {
 185         clipboard->seqno_timestamp = tm;
 186         clipboard->seqno++;
 187     }
 188     return clipboard->seqno;
 189 }
 190
 191
 192 DECL_HANDLER(set_clipboard_info)
 193 {
 194     struct clipboard *clipboard = get_process_clipboard();
 195
 196     if (!clipboard) return;
 197
 198     reply->old_clipboard = clipboard->open_win;
 199     reply->old_owner     = clipboard->owner_win;
 200     reply->old_viewer    = clipboard->viewer;
 201
 202     if (req->flags & SET_CB_OPEN)
 203     {
 204         if (clipboard->open_thread)
 205         {
 206             /* clipboard already opened */
 207             set_error(STATUS_WAS_LOCKED);
 208             return;
 209         }
 210
 211         if (!set_clipboard_window( clipboard, req->clipboard, 0 )) return;
 212     }
 213     else if (req->flags & SET_CB_CLOSE)
 214     {
 215         if (clipboard->open_thread != current)
 216         {
 217             set_win32_error(ERROR_CLIPBOARD_NOT_OPEN);
 218             return;
 219         }
 220
 221         if (!set_clipboard_window( clipboard, 0, 1 )) return;
 222     }
 223
 224     if (req->flags & SET_CB_OWNER)
 225     {
 226         if (!set_clipboard_owner( clipboard, req->owner, 0 )) return;
 227     }
 228     else if (req->flags & SET_CB_RELOWNER)
 229     {
 230         if (!set_clipboard_owner( clipboard, 0, 1 )) return;
 231     }
 232
 233     if (req->flags & SET_CB_VIEWER) clipboard->viewer = req->viewer;
 234
 235     if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
 236
 237     reply->seqno = get_seqno( clipboard );
 238
 239     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
 240     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
 241     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
 242         reply->flags |= CB_PROCESS;
 243 }