server/queue.c

   1 /*
   2  * Server-side message queues
   3  *
   4  * Copyright (C) 2000 Alexandre Julliard
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <assert.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28
  29 #include "handle.h"
  30 #include "thread.h"
  31 #include "process.h"
  32 #include "request.h"
  33 #include "user.h"
  34
  35 enum message_kind { SEND_MESSAGE, POST_MESSAGE, COOKED_HW_MESSAGE, RAW_HW_MESSAGE };
  36 #define NB_MSG_KINDS (RAW_HW_MESSAGE+1)
  37
  38
  39 struct message_result
  40 {
  41     struct message_result *send_next;   /* next in sender list */
  42     struct message_result *recv_next;   /* next in receiver list */
  43     struct msg_queue      *sender;      /* sender queue */
  44     struct msg_queue      *receiver;    /* receiver queue */
  45     int                    replied;     /* has it been replied to? */
  46     unsigned int           result;      /* reply result */
  47     unsigned int           error;       /* error code to pass back to sender */
  48     void                  *data;        /* message reply data */
  49     unsigned int           data_size;   /* size of message reply data */
  50     struct timeout_user   *timeout;     /* result timeout */
  51 };
  52
  53 struct message
  54 {
  55     struct message        *next;      /* next message in list */
  56     struct message        *prev;      /* prev message in list */
  57     enum message_type      type;      /* message type */
  58     user_handle_t          win;       /* window handle */
  59     unsigned int           msg;       /* message code */
  60     unsigned int           wparam;    /* parameters */
  61     unsigned int           lparam;    /* parameters */
  62     int                    x;         /* x position */
  63     int                    y;         /* y position */
  64     unsigned int           time;      /* message time */
  65     unsigned int           info;      /* extra info */
  66     void                  *data;      /* message data for sent messages */
  67     unsigned int           data_size; /* size of message data */
  68     struct message_result *result;    /* result in sender queue */
  69 };
  70
  71 struct message_list
  72 {
  73     struct message *first;     /* head of list */
  74     struct message *last;      /* tail of list */
  75 };
  76
  77 struct timer
  78 {
  79     struct timer   *next;      /* next timer in list */
  80     struct timer   *prev;      /* prev timer in list */
  81     struct timeval  when;      /* next expiration */
  82     unsigned int    rate;      /* timer rate in ms */
  83     user_handle_t   win;       /* window handle */
  84     unsigned int    msg;       /* message to post */
  85     unsigned int    id;        /* timer id */
  86     unsigned int    lparam;    /* lparam for message */
  87 };
  88
  89 struct msg_queue
  90 {
  91     struct object          obj;           /* object header */
  92     unsigned int           wake_bits;     /* wakeup bits */
  93     unsigned int           wake_mask;     /* wakeup mask */
  94     unsigned int           changed_bits;  /* changed wakeup bits */
  95     unsigned int           changed_mask;  /* changed wakeup mask */
  96     int                    paint_count;   /* pending paint messages count */
  97     struct message_list    msg_list[NB_MSG_KINDS];  /* lists of messages */
  98     struct message_result *send_result;   /* stack of sent messages waiting for result */
  99     struct message_result *recv_result;   /* stack of received messages waiting for result */
 100     struct message        *last_msg;      /* last msg returned to the app and not removed */
 101     enum message_kind      last_msg_kind; /* message kind of last_msg */
 102     struct timer          *first_timer;   /* head of timer list */
 103     struct timer          *last_timer;    /* tail of timer list */
 104     struct timer          *next_timer;    /* next timer to expire */
 105     struct timeout_user   *timeout;       /* timeout for next timer to expire */
 106 };
 107
 108 static void msg_queue_dump( struct object *obj, int verbose );
 109 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry );
 110 static void msg_queue_remove_queue( struct object *obj, struct wait_queue_entry *entry );
 111 static int msg_queue_signaled( struct object *obj, struct thread *thread );
 112 static int msg_queue_satisfied( struct object *obj, struct thread *thread );
 113 static void msg_queue_destroy( struct object *obj );
 114 static void timer_callback( void *private );
 115
 116 static const struct object_ops msg_queue_ops =
 117 {
 118     sizeof(struct msg_queue),  /* size */
 119     msg_queue_dump,            /* dump */
 120     msg_queue_add_queue,       /* add_queue */
 121     msg_queue_remove_queue,    /* remove_queue */
 122     msg_queue_signaled,        /* signaled */
 123     msg_queue_satisfied,       /* satisfied */
 124     NULL,                      /* get_poll_events */
 125     NULL,                      /* poll_event */
 126     no_get_fd,                 /* get_fd */
 127     no_flush,                  /* flush */
 128     no_get_file_info,          /* get_file_info */
 129     NULL,                      /* queue_async */
 130     msg_queue_destroy          /* destroy */
 131 };
 132
 133
 134 static struct msg_queue *create_msg_queue( struct thread *thread )
 135 {
 136     struct msg_queue *queue;
 137     int i;
 138
 139     if ((queue = alloc_object( &msg_queue_ops, -1 )))
 140     {
 141         queue->wake_bits       = 0;
 142         queue->wake_mask       = 0;
 143         queue->changed_bits    = 0;
 144         queue->changed_mask    = 0;
 145         queue->paint_count     = 0;
 146         queue->send_result     = NULL;
 147         queue->recv_result     = NULL;
 148         queue->last_msg        = NULL;
 149         queue->first_timer     = NULL;
 150         queue->last_timer      = NULL;
 151         queue->next_timer      = NULL;
 152         queue->timeout         = NULL;
 153         for (i = 0; i < NB_MSG_KINDS; i++)
 154             queue->msg_list[i].first = queue->msg_list[i].last = NULL;
 155
 156         thread->queue = queue;
 157         if (!thread->process->queue)
 158             thread->process->queue = (struct msg_queue *)grab_object( queue );
 159     }
 160     return queue;
 161 }
 162
 163 /* check the queue status */
 164 inline static int is_signaled( struct msg_queue *queue )
 165 {
 166     return ((queue->wake_bits & queue->wake_mask) || (queue->changed_bits & queue->changed_mask));
 167 }
 168
 169 /* set some queue bits */
 170 inline static void set_queue_bits( struct msg_queue *queue, unsigned int bits )
 171 {
 172     queue->wake_bits |= bits;
 173     queue->changed_bits |= bits;
 174     if (is_signaled( queue )) wake_up( &queue->obj, 0 );
 175 }
 176
 177 /* clear some queue bits */
 178 inline static void clear_queue_bits( struct msg_queue *queue, unsigned int bits )
 179 {
 180     queue->wake_bits &= ~bits;
 181     queue->changed_bits &= ~bits;
 182 }
 183
 184 /* get the QS_* bit corresponding to a given hardware message */
 185 inline static int get_hardware_msg_bit( struct message *msg )
 186 {
 187     if (msg->msg == WM_MOUSEMOVE || msg->msg == WM_NCMOUSEMOVE) return QS_MOUSEMOVE;
 188     if (msg->msg >= WM_KEYFIRST && msg->msg <= WM_KEYLAST) return QS_KEY;
 189     return QS_MOUSEBUTTON;
 190 }
 191
 192 /* get the current thread queue, creating it if needed */
 193 inline static struct msg_queue *get_current_queue(void)
 194 {
 195     struct msg_queue *queue = current->queue;
 196     if (!queue) queue = create_msg_queue( current );
 197     return queue;
 198 }
 199
 200 /* append a message to the end of a list */
 201 inline static void append_message( struct message_list *list, struct message *msg )
 202 {
 203     msg->next = NULL;
 204     if ((msg->prev = list->last)) msg->prev->next = msg;
 205     else list->first = msg;
 206     list->last = msg;
 207 }
 208
 209 /* unlink a message from a list it */
 210 inline static void unlink_message( struct message_list *list, struct message *msg )
 211 {
 212     if (msg->next) msg->next->prev = msg->prev;
 213     else list->last = msg->prev;
 214     if (msg->prev) msg->prev->next = msg->next;
 215     else list->first = msg->next;
 216 }
 217
 218 /* try to merge a message with the last in the list; return 1 if successful */
 219 static int merge_message( struct message_list *list, const struct message *msg )
 220 {
 221     struct message *prev = list->last;
 222
 223     if (!prev) return 0;
 224     if (prev->result) return 0;
 225     if (prev->win != msg->win) return 0;
 226     if (prev->msg != msg->msg) return 0;
 227     if (prev->type != msg->type) return 0;
 228     /* now we can merge it */
 229     prev->wparam  = msg->wparam;
 230     prev->lparam  = msg->lparam;
 231     prev->x       = msg->x;
 232     prev->y       = msg->y;
 233     prev->time    = msg->time;
 234     prev->info    = msg->info;
 235     return 1;
 236 }
 237
 238 /* free a result structure */
 239 static void free_result( struct message_result *result )
 240 {
 241     if (result->timeout) remove_timeout_user( result->timeout );
 242     if (result->data) free( result->data );
 243     free( result );
 244 }
 245
 246 /* store the message result in the appropriate structure */
 247 static void store_message_result( struct message_result *res, unsigned int result,
 248                                   unsigned int error )
 249 {
 250     res->result  = result;
 251     res->error   = error;
 252     res->replied = 1;
 253     if (res->timeout)
 254     {
 255         remove_timeout_user( res->timeout );
 256         res->timeout = NULL;
 257     }
 258     /* wake sender queue if waiting on this result */
 259     if (res->sender && res->sender->send_result == res)
 260         set_queue_bits( res->sender, QS_SMRESULT );
 261 }
 262
 263 /* free a message when deleting a queue or window */
 264 static void free_message( struct message *msg )
 265 {
 266     struct message_result *result = msg->result;
 267     if (result)
 268     {
 269         if (result->sender)
 270         {
 271             result->receiver = NULL;
 272             store_message_result( result, 0, STATUS_ACCESS_DENIED /*FIXME*/ );
 273         }
 274         else free_result( result );
 275     }
 276     if (msg->data) free( msg->data );
 277     free( msg );
 278 }
 279
 280 /* remove (and free) a message from a message list */
 281 static void remove_queue_message( struct msg_queue *queue, struct message *msg,
 282                                   enum message_kind kind )
 283 {
 284     int clr_bit;
 285     struct message *other;
 286
 287     if (queue->last_msg == msg) queue->last_msg = NULL;
 288     unlink_message( &queue->msg_list[kind], msg );
 289     switch(kind)
 290     {
 291     case SEND_MESSAGE:
 292         if (!queue->msg_list[kind].first) clear_queue_bits( queue, QS_SENDMESSAGE );
 293         break;
 294     case POST_MESSAGE:
 295         if (!queue->msg_list[kind].first) clear_queue_bits( queue, QS_POSTMESSAGE );
 296         break;
 297     case COOKED_HW_MESSAGE:
 298     case RAW_HW_MESSAGE:
 299         clr_bit = get_hardware_msg_bit( msg );
 300         for (other = queue->msg_list[kind].first; other; other = other->next)
 301             if (get_hardware_msg_bit( other ) == clr_bit) break;
 302         if (!other) clear_queue_bits( queue, clr_bit );
 303         break;
 304     }
 305     free_message( msg );
 306 }
 307
 308 /* message timed out without getting a reply */
 309 static void result_timeout( void *private )
 310 {
 311     struct message_result *result = private;
 312
 313     assert( !result->replied );
 314
 315     result->timeout = NULL;
 316     store_message_result( result, 0, STATUS_TIMEOUT );
 317 }
 318
 319 /* allocate and fill a message result structure */
 320 static struct message_result *alloc_message_result( struct msg_queue *send_queue,
 321                                                     struct msg_queue *recv_queue,
 322                                                     unsigned int timeout )
 323 {
 324     struct message_result *result = mem_alloc( sizeof(*result) );
 325     if (result)
 326     {
 327         /* put the result on the sender result stack */
 328         result->sender    = send_queue;
 329         result->receiver  = recv_queue;
 330         result->replied   = 0;
 331         result->data      = NULL;
 332         result->data_size = 0;
 333         result->timeout   = NULL;
 334         result->send_next = send_queue->send_result;
 335         send_queue->send_result = result;
 336         if (timeout != -1)
 337         {
 338             struct timeval when;
 339             gettimeofday( &when, 0 );
 340             add_timeout( &when, timeout );
 341             result->timeout = add_timeout_user( &when, result_timeout, result );
 342         }
 343     }
 344     return result;
 345 }
 346
 347 /* receive a message, removing it from the sent queue */
 348 static void receive_message( struct msg_queue *queue, struct message *msg,
 349                              struct get_message_reply *reply )
 350 {
 351     struct message_result *result = msg->result;
 352
 353     reply->total = msg->data_size;
 354     if (msg->data_size > get_reply_max_size())
 355     {
 356         set_error( STATUS_BUFFER_OVERFLOW );
 357         return;
 358     }
 359     reply->type   = msg->type;
 360     reply->win    = msg->win;
 361     reply->msg    = msg->msg;
 362     reply->wparam = msg->wparam;
 363     reply->lparam = msg->lparam;
 364     reply->x      = msg->x;
 365     reply->y      = msg->y;
 366     reply->time   = msg->time;
 367     reply->info   = msg->info;
 368
 369     if (msg->data) set_reply_data_ptr( msg->data, msg->data_size );
 370
 371     unlink_message( &queue->msg_list[SEND_MESSAGE], msg );
 372     /* put the result on the receiver result stack */
 373     if (result)
 374     {
 375         result->recv_next  = queue->recv_result;
 376         queue->recv_result = result;
 377     }
 378     free( msg );
 379     if (!queue->msg_list[SEND_MESSAGE].first) clear_queue_bits( queue, QS_SENDMESSAGE );
 380 }
 381
 382 /* set the result of the current received message */
 383 static void reply_message( struct msg_queue *queue, unsigned int result,
 384                            unsigned int error, int remove, const void *data, size_t len )
 385 {
 386     struct message_result *res = queue->recv_result;
 387
 388     if (remove)
 389     {
 390         queue->recv_result = res->recv_next;
 391         res->receiver = NULL;
 392         if (!res->sender)  /* no one waiting for it */
 393         {
 394             free_result( res );
 395             return;
 396         }
 397     }
 398     if (!res->replied)
 399     {
 400         if (len && (res->data = memdup( data, len ))) res->data_size = len;
 401         store_message_result( res, result, error );
 402     }
 403 }
 404
 405 /* empty a message list and free all the messages */
 406 static void empty_msg_list( struct message_list *list )
 407 {
 408     struct message *msg = list->first;
 409     while (msg)
 410     {
 411         struct message *next = msg->next;
 412         free_message( msg );
 413         msg = next;
 414     }
 415 }
 416
 417 /* cleanup all pending results when deleting a queue */
 418 static void cleanup_results( struct msg_queue *queue )
 419 {
 420     struct message_result *result, *next;
 421
 422     result = queue->send_result;
 423     while (result)
 424     {
 425         next = result->send_next;
 426         result->sender = NULL;
 427         if (!result->receiver) free_result( result );
 428         result = next;
 429     }
 430
 431     while (queue->recv_result)
 432         reply_message( queue, 0, STATUS_ACCESS_DENIED /*FIXME*/, 1, NULL, 0 );
 433 }
 434
 435 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry )
 436 {
 437     struct msg_queue *queue = (struct msg_queue *)obj;
 438     struct process *process = entry->thread->process;
 439
 440     /* a thread can only wait on its own queue */
 441     if (entry->thread->queue != queue)
 442     {
 443         set_error( STATUS_ACCESS_DENIED );
 444         return 0;
 445     }
 446     /* if waiting on the main process queue, set the idle event */
 447     if (process->queue == queue)
 448     {
 449         if (process->idle_event) set_event( process->idle_event );
 450     }
 451     add_queue( obj, entry );
 452     return 1;
 453 }
 454
 455 static void msg_queue_remove_queue(struct object *obj, struct wait_queue_entry *entry )
 456 {
 457     struct msg_queue *queue = (struct msg_queue *)obj;
 458     struct process *process = entry->thread->process;
 459
 460     remove_queue( obj, entry );
 461
 462     assert( entry->thread->queue == queue );
 463
 464     /* if waiting on the main process queue, reset the idle event */
 465     if (process->queue == queue)
 466     {
 467         if (process->idle_event) reset_event( process->idle_event );
 468     }
 469 }
 470
 471 static void msg_queue_dump( struct object *obj, int verbose )
 472 {
 473     struct msg_queue *queue = (struct msg_queue *)obj;
 474     fprintf( stderr, "Msg queue bits=%x mask=%x\n",
 475              queue->wake_bits, queue->wake_mask );
 476 }
 477
 478 static int msg_queue_signaled( struct object *obj, struct thread *thread )
 479 {
 480     struct msg_queue *queue = (struct msg_queue *)obj;
 481     return is_signaled( queue );
 482 }
 483
 484 static int msg_queue_satisfied( struct object *obj, struct thread *thread )
 485 {
 486     struct msg_queue *queue = (struct msg_queue *)obj;
 487     queue->wake_mask = 0;
 488     queue->changed_mask = 0;
 489     return 0;  /* Not abandoned */
 490 }
 491
 492 static void msg_queue_destroy( struct object *obj )
 493 {
 494     struct msg_queue *queue = (struct msg_queue *)obj;
 495     struct timer *timer = queue->first_timer;
 496     int i;
 497
 498     cleanup_results( queue );
 499     for (i = 0; i < NB_MSG_KINDS; i++) empty_msg_list( &queue->msg_list[i] );
 500
 501     while (timer)
 502     {
 503         struct timer *next = timer->next;
 504         free( timer );
 505         timer = next;
 506     }
 507     if (queue->timeout) remove_timeout_user( queue->timeout );
 508 }
 509
 510 /* set the next timer to expire */
 511 static void set_next_timer( struct msg_queue *queue, struct timer *timer )
 512 {
 513     if (queue->timeout)
 514     {
 515         remove_timeout_user( queue->timeout );
 516         queue->timeout = NULL;
 517     }
 518     if ((queue->next_timer = timer))
 519         queue->timeout = add_timeout_user( &timer->when, timer_callback, queue );
 520
 521     /* set/clear QS_TIMER bit */
 522     if (queue->next_timer == queue->first_timer)
 523         clear_queue_bits( queue, QS_TIMER );
 524     else
 525         set_queue_bits( queue, QS_TIMER );
 526 }
 527
 528 /* callback for the next timer expiration */
 529 static void timer_callback( void *private )
 530 {
 531     struct msg_queue *queue = private;
 532
 533     queue->timeout = NULL;
 534     /* move on to the next timer */
 535     set_next_timer( queue, queue->next_timer->next );
 536 }
 537
 538 /* link a timer at its rightful place in the queue list */
 539 static void link_timer( struct msg_queue *queue, struct timer *timer )
 540 {
 541     struct timer *pos = queue->next_timer;
 542
 543     while (pos && time_before( &pos->when, &timer->when )) pos = pos->next;
 544
 545     if (pos) /* insert before pos */
 546     {
 547         if ((timer->prev = pos->prev)) timer->prev->next = timer;
 548         else queue->first_timer = timer;
 549         timer->next = pos;
 550         pos->prev = timer;
 551     }
 552     else  /* insert at end */
 553     {
 554         timer->next = NULL;
 555         timer->prev = queue->last_timer;
 556         if (queue->last_timer) queue->last_timer->next = timer;
 557         else queue->first_timer = timer;
 558         queue->last_timer = timer;
 559     }
 560     /* check if we replaced the next timer */
 561     if (pos == queue->next_timer) set_next_timer( queue, timer );
 562 }
 563
 564 /* remove a timer from the queue timer list */
 565 static void unlink_timer( struct msg_queue *queue, struct timer *timer )
 566 {
 567     if (timer->next) timer->next->prev = timer->prev;
 568     else queue->last_timer = timer->prev;
 569     if (timer->prev) timer->prev->next = timer->next;
 570     else queue->first_timer = timer->next;
 571     /* check if we removed the next timer */
 572     if (queue->next_timer == timer) set_next_timer( queue, timer->next );
 573     else if (queue->next_timer == queue->first_timer) clear_queue_bits( queue, QS_TIMER );
 574 }
 575
 576 /* restart an expired timer */
 577 static void restart_timer( struct msg_queue *queue, struct timer *timer )
 578 {
 579     struct timeval now;
 580     unlink_timer( queue, timer );
 581     gettimeofday( &now, 0 );
 582     while (!time_before( &now, &timer->when )) add_timeout( &timer->when, timer->rate );
 583     link_timer( queue, timer );
 584 }
 585
 586 /* find an expired timer matching the filtering parameters */
 587 static struct timer *find_expired_timer( struct msg_queue *queue, user_handle_t win,
 588                                          unsigned int get_first, unsigned int get_last,
 589                                          int remove )
 590 {
 591     struct timer *timer;
 592     for (timer = queue->first_timer; (timer && timer != queue->next_timer); timer = timer->next)
 593     {
 594         if (win && timer->win != win) continue;
 595         if (timer->msg >= get_first && timer->msg <= get_last)
 596         {
 597             if (remove) restart_timer( queue, timer );
 598             return timer;
 599         }
 600     }
 601     return NULL;
 602 }
 603
 604 /* kill a timer */
 605 static int kill_timer( struct msg_queue *queue, user_handle_t win,
 606                        unsigned int msg, unsigned int id )
 607 {
 608     struct timer *timer;
 609
 610     for (timer = queue->first_timer; timer; timer = timer->next)
 611     {
 612         if (timer->win != win || timer->msg != msg || timer->id != id) continue;
 613         unlink_timer( queue, timer );
 614         free( timer );
 615         return 1;
 616     }
 617     return 0;
 618 }
 619
 620 /* add a timer */
 621 static struct timer *set_timer( struct msg_queue *queue, unsigned int rate )
 622 {
 623     struct timer *timer = mem_alloc( sizeof(*timer) );
 624     if (timer)
 625     {
 626         timer->rate  = rate;
 627         gettimeofday( &timer->when, 0 );
 628         add_timeout( &timer->when, rate );
 629         link_timer( queue, timer );
 630     }
 631     return timer;
 632 }
 633
 634
 635 /* increment (or decrement if 'incr' is negative) the queue paint count */
 636 void inc_queue_paint_count( struct thread *thread, int incr )
 637 {
 638     struct msg_queue *queue = thread->queue;
 639
 640     assert( queue );
 641
 642     if ((queue->paint_count += incr) < 0) queue->paint_count = 0;
 643
 644     if (queue->paint_count)
 645         set_queue_bits( queue, QS_PAINT );
 646     else
 647         clear_queue_bits( queue, QS_PAINT );
 648 }
 649
 650
 651 /* remove all messages and timers belonging to a certain window */
 652 void queue_cleanup_window( struct thread *thread, user_handle_t win )
 653 {
 654     struct msg_queue *queue = thread->queue;
 655     struct timer *timer;
 656     struct message *msg;
 657     int i;
 658
 659     if (!queue) return;
 660
 661     /* remove timers */
 662     timer = queue->first_timer;
 663     while (timer)
 664     {
 665         struct timer *next = timer->next;
 666         if (timer->win == win)
 667         {
 668             unlink_timer( queue, timer );
 669             free( timer );
 670         }
 671         timer = next;
 672     }
 673
 674     /* remove messages */
 675     for (i = 0; i < NB_MSG_KINDS; i++)
 676     {
 677         msg = queue->msg_list[i].first;
 678         while (msg)
 679         {
 680             struct message *next = msg->next;
 681             if (msg->win == win) remove_queue_message( queue, msg, i );
 682             msg = next;
 683         }
 684     }
 685 }
 686
 687 /* get the message queue of the current thread */
 688 DECL_HANDLER(get_msg_queue)
 689 {
 690     struct msg_queue *queue = get_current_queue();
 691
 692     reply->handle = 0;
 693     if (queue) reply->handle = alloc_handle( current->process, queue, SYNCHRONIZE, 0 );
 694 }
 695
 696
 697 /* set the current message queue wakeup mask */
 698 DECL_HANDLER(set_queue_mask)
 699 {
 700     struct msg_queue *queue = get_current_queue();
 701
 702     if (queue)
 703     {
 704         queue->wake_mask    = req->wake_mask;
 705         queue->changed_mask = req->changed_mask;
 706         reply->wake_bits    = queue->wake_bits;
 707         reply->changed_bits = queue->changed_bits;
 708         if (is_signaled( queue ))
 709         {
 710             /* if skip wait is set, do what would have been done in the subsequent wait */
 711             if (req->skip_wait) msg_queue_satisfied( &queue->obj, current );
 712             else wake_up( &queue->obj, 0 );
 713         }
 714     }
 715 }
 716
 717
 718 /* get the current message queue status */
 719 DECL_HANDLER(get_queue_status)
 720 {
 721     struct msg_queue *queue = current->queue;
 722     if (queue)
 723     {
 724         reply->wake_bits    = queue->wake_bits;
 725         reply->changed_bits = queue->changed_bits;
 726         if (req->clear) queue->changed_bits = 0;
 727     }
 728     else reply->wake_bits = reply->changed_bits = 0;
 729 }
 730
 731
 732 /* send a message to a thread queue */
 733 DECL_HANDLER(send_message)
 734 {
 735     struct message *msg;
 736     struct msg_queue *send_queue = get_current_queue();
 737     struct msg_queue *recv_queue;
 738     struct thread *thread = get_thread_from_id( req->id );
 739
 740     if (!thread) return;
 741
 742     if (!(recv_queue = thread->queue))
 743     {
 744         set_error( STATUS_INVALID_PARAMETER );
 745         release_object( thread );
 746         return;
 747     }
 748
 749     if ((msg = mem_alloc( sizeof(*msg) )))
 750     {
 751         msg->type      = req->type;
 752         msg->win       = get_user_full_handle( req->win );
 753         msg->msg       = req->msg;
 754         msg->wparam    = req->wparam;
 755         msg->lparam    = req->lparam;
 756         msg->time      = req->time;
 757         msg->x         = req->x;
 758         msg->y         = req->y;
 759         msg->info      = req->info;
 760         msg->result    = NULL;
 761         msg->data      = NULL;
 762         msg->data_size = 0;
 763
 764         switch(msg->type)
 765         {
 766         case MSG_OTHER_PROCESS:
 767             msg->data_size = get_req_data_size();
 768             if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
 769             {
 770                 free( msg );
 771                 break;
 772             }
 773             /* fall through */
 774         case MSG_ASCII:
 775         case MSG_UNICODE:
 776         case MSG_CALLBACK:
 777             if (!(msg->result = alloc_message_result( send_queue, recv_queue, req->timeout )))
 778             {
 779                 free( msg );
 780                 break;
 781             }
 782             /* fall through */
 783         case MSG_NOTIFY:
 784             append_message( &recv_queue->msg_list[SEND_MESSAGE], msg );
 785             set_queue_bits( recv_queue, QS_SENDMESSAGE );
 786             break;
 787         case MSG_POSTED:
 788             /* needed for posted DDE messages */
 789             msg->data_size = get_req_data_size();
 790             if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
 791             {
 792                 free( msg );
 793                 break;
 794             }
 795             append_message( &recv_queue->msg_list[POST_MESSAGE], msg );
 796             set_queue_bits( recv_queue, QS_POSTMESSAGE );
 797             break;
 798         case MSG_HARDWARE_RAW:
 799         case MSG_HARDWARE_COOKED:
 800             {
 801                 struct message_list *list = ((msg->type == MSG_HARDWARE_RAW) ?
 802                                              &recv_queue->msg_list[RAW_HW_MESSAGE] :
 803                                              &recv_queue->msg_list[COOKED_HW_MESSAGE]);
 804                 if (msg->msg == WM_MOUSEMOVE && merge_message( list, msg ))
 805                 {
 806                     free( msg );
 807                     break;
 808                 }
 809                 append_message( list, msg );
 810                 set_queue_bits( recv_queue, get_hardware_msg_bit(msg) );
 811                 break;
 812             }
 813         default:
 814             set_error( STATUS_INVALID_PARAMETER );
 815             free( msg );
 816             break;
 817         }
 818     }
 819     release_object( thread );
 820 }
 821
 822 /* return a message to the application, removing it from the queue if needed */
 823 static void return_message_to_app( struct msg_queue *queue, int flags,
 824                                    struct get_message_reply *reply,
 825                                    struct message *msg, enum message_kind kind )
 826 {
 827     reply->total = msg->data_size;
 828     if (msg->data_size > get_reply_max_size())
 829     {
 830         set_error( STATUS_BUFFER_OVERFLOW );
 831         return;
 832     }
 833     reply->type   = msg->type;
 834     reply->win    = msg->win;
 835     reply->msg    = msg->msg;
 836     reply->wparam = msg->wparam;
 837     reply->lparam = msg->lparam;
 838     reply->x      = msg->x;
 839     reply->y      = msg->y;
 840     reply->time   = msg->time;
 841     reply->info   = msg->info;
 842
 843     /* raw messages always get removed */
 844     if ((msg->type == MSG_HARDWARE_RAW) || (flags & GET_MSG_REMOVE))
 845     {
 846         queue->last_msg = NULL;
 847         if (msg->data)
 848         {
 849             set_reply_data_ptr( msg->data, msg->data_size );
 850             msg->data = NULL;
 851             msg->data_size = 0;
 852         }
 853         remove_queue_message( queue, msg, kind );
 854     }
 855     else  /* remember it as the last returned message */
 856     {
 857         if (msg->data) set_reply_data( msg->data, msg->data_size );
 858         queue->last_msg = msg;
 859         queue->last_msg_kind = kind;
 860     }
 861 }
 862
 863
 864 inline static struct message *find_matching_message( const struct message_list *list,
 865                                                      user_handle_t win,
 866                                                      unsigned int first, unsigned int last )
 867 {
 868     struct message *msg;
 869
 870     for (msg = list->first; msg; msg = msg->next)
 871     {
 872         /* check against the filters */
 873         if (msg->msg == WM_QUIT) break;  /* WM_QUIT is never filtered */
 874         if (win && msg->win && msg->win != win && !is_child_window( win, msg->win )) continue;
 875         if (msg->msg < first) continue;
 876         if (msg->msg > last) continue;
 877         break; /* found one */
 878     }
 879     return msg;
 880 }
 881
 882
 883 /* get a message from the current queue */
 884 DECL_HANDLER(get_message)
 885 {
 886     struct timer *timer;
 887     struct message *msg;
 888     struct msg_queue *queue = get_current_queue();
 889     user_handle_t get_win = get_user_full_handle( req->get_win );
 890
 891     if (!queue) return;
 892
 893     /* first check for sent messages */
 894     if ((msg = queue->msg_list[SEND_MESSAGE].first))
 895     {
 896         receive_message( queue, msg, reply );
 897         return;
 898     }
 899     if (req->flags & GET_MSG_SENT_ONLY) goto done;  /* nothing else to check */
 900
 901     /* if requested, remove the last returned but not yet removed message */
 902     if ((req->flags & GET_MSG_REMOVE_LAST) && queue->last_msg)
 903         remove_queue_message( queue, queue->last_msg, queue->last_msg_kind );
 904     queue->last_msg = NULL;
 905
 906     /* clear changed bits so we can wait on them if we don't find a message */
 907     queue->changed_bits = 0;
 908
 909     /* then check for posted messages */
 910     if ((msg = find_matching_message( &queue->msg_list[POST_MESSAGE], get_win,
 911                                       req->get_first, req->get_last )))
 912     {
 913         return_message_to_app( queue, req->flags, reply, msg, POST_MESSAGE );
 914         return;
 915     }
 916
 917     /* then check for cooked hardware messages */
 918     if ((msg = find_matching_message( &queue->msg_list[COOKED_HW_MESSAGE], get_win,
 919                                       req->get_first, req->get_last )))
 920     {
 921         return_message_to_app( queue, req->flags, reply, msg, COOKED_HW_MESSAGE );
 922         return;
 923     }
 924
 925     /* then check for any raw hardware message */
 926     if ((msg = queue->msg_list[RAW_HW_MESSAGE].first))
 927     {
 928         return_message_to_app( queue, req->flags, reply, msg, RAW_HW_MESSAGE );
 929         return;
 930     }
 931
 932     /* now check for WM_PAINT */
 933     if (queue->paint_count &&
 934         (WM_PAINT >= req->get_first) && (WM_PAINT <= req->get_last) &&
 935         (reply->win = find_window_to_repaint( get_win, current )))
 936     {
 937         reply->type   = MSG_POSTED;
 938         reply->msg    = WM_PAINT;
 939         reply->wparam = 0;
 940         reply->lparam = 0;
 941         reply->x      = 0;
 942         reply->y      = 0;
 943         reply->time   = get_tick_count();
 944         reply->info   = 0;
 945         return;
 946     }
 947
 948     /* now check for timer */
 949     if ((timer = find_expired_timer( queue, get_win, req->get_first,
 950                                      req->get_last, (req->flags & GET_MSG_REMOVE) )))
 951     {
 952         reply->type   = MSG_POSTED;
 953         reply->win    = timer->win;
 954         reply->msg    = timer->msg;
 955         reply->wparam = timer->id;
 956         reply->lparam = timer->lparam;
 957         reply->x      = 0;
 958         reply->y      = 0;
 959         reply->time   = get_tick_count();
 960         reply->info   = 0;
 961         return;
 962     }
 963
 964  done:
 965     set_error( STATUS_PENDING );  /* FIXME */
 966 }
 967
 968
 969 /* reply to a sent message */
 970 DECL_HANDLER(reply_message)
 971 {
 972     if (current->queue && current->queue->recv_result)
 973         reply_message( current->queue, req->result, 0, req->remove,
 974                        get_req_data(), get_req_data_size() );
 975     else
 976         set_error( STATUS_ACCESS_DENIED );
 977 }
 978
 979
 980 /* retrieve the reply for the last message sent */
 981 DECL_HANDLER(get_message_reply)
 982 {
 983     struct msg_queue *queue = current->queue;
 984
 985     if (queue)
 986     {
 987         struct message_result *result = queue->send_result;
 988
 989         set_error( STATUS_PENDING );
 990         reply->result = 0;
 991
 992         if (result && (result->replied || req->cancel))
 993         {
 994             if (result->replied)
 995             {
 996                 reply->result = result->result;
 997                 set_error( result->error );
 998                 if (result->data)
 999                 {
1000                     size_t data_len = min( result->data_size, get_reply_max_size() );
1001                     set_reply_data_ptr( result->data, data_len );
1002                     result->data = NULL;
1003                     result->data_size = 0;
1004                 }
1005             }
1006             queue->send_result = result->send_next;
1007             result->sender = NULL;
1008             if (!result->receiver) free_result( result );
1009             if (!queue->send_result || !queue->send_result->replied)
1010                 clear_queue_bits( queue, QS_SMRESULT );
1011         }
1012     }
1013     else set_error( STATUS_ACCESS_DENIED );
1014 }
1015
1016
1017 /* set a window timer */
1018 DECL_HANDLER(set_win_timer)
1019 {
1020     struct timer *timer;
1021     struct msg_queue *queue = get_current_queue();
1022     user_handle_t win = get_user_full_handle( req->win );
1023
1024     if (!queue) return;
1025
1026     /* remove it if it existed already */
1027     if (win) kill_timer( queue, win, req->msg, req->id );
1028
1029     if ((timer = set_timer( queue, req->rate )))
1030     {
1031         timer->win    = win;
1032         timer->msg    = req->msg;
1033         timer->id     = req->id;
1034         timer->lparam = req->lparam;
1035     }
1036 }
1037
1038 /* kill a window timer */
1039 DECL_HANDLER(kill_win_timer)
1040 {
1041     struct msg_queue *queue = current->queue;
1042
1043     if (!queue || !kill_timer( queue, get_user_full_handle(req->win), req->msg, req->id ))
1044         set_error( STATUS_INVALID_PARAMETER );
1045 }