git.oblomov.eu Git - wine/blob - 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 /* post a message to a window; used by socket handling */
 688 void post_message( user_handle_t win, unsigned int message,
 689                    unsigned int wparam, unsigned int lparam )
 690 {
 691     struct message *msg;
 692     struct thread *thread = get_window_thread( win );
 693
 694     if (!thread) return;
 695
 696     if (thread->queue && (msg = mem_alloc( sizeof(*msg) )))
 697     {
 698         msg->type      = MSG_POSTED;
 699         msg->win       = get_user_full_handle( win );
 700         msg->msg       = message;
 701         msg->wparam    = wparam;
 702         msg->lparam    = lparam;
 703         msg->time      = get_tick_count();
 704         msg->x         = 0;
 705         msg->y         = 0;
 706         msg->info      = 0;
 707         msg->result    = NULL;
 708         msg->data      = NULL;
 709         msg->data_size = 0;
 710
 711         append_message( &thread->queue->msg_list[POST_MESSAGE], msg );
 712         set_queue_bits( thread->queue, QS_POSTMESSAGE );
 713     }
 714     release_object( thread );
 715 }
 716
 717
 718 /* get the message queue of the current thread */
 719 DECL_HANDLER(get_msg_queue)
 720 {
 721     struct msg_queue *queue = get_current_queue();
 722
 723     reply->handle = 0;
 724     if (queue) reply->handle = alloc_handle( current->process, queue, SYNCHRONIZE, 0 );
 725 }
 726
 727
 728 /* set the current message queue wakeup mask */
 729 DECL_HANDLER(set_queue_mask)
 730 {
 731     struct msg_queue *queue = get_current_queue();
 732
 733     if (queue)
 734     {
 735         queue->wake_mask    = req->wake_mask;
 736         queue->changed_mask = req->changed_mask;
 737         reply->wake_bits    = queue->wake_bits;
 738         reply->changed_bits = queue->changed_bits;
 739         if (is_signaled( queue ))
 740         {
 741             /* if skip wait is set, do what would have been done in the subsequent wait */
 742             if (req->skip_wait) msg_queue_satisfied( &queue->obj, current );
 743             else wake_up( &queue->obj, 0 );
 744         }
 745     }
 746 }
 747
 748
 749 /* get the current message queue status */
 750 DECL_HANDLER(get_queue_status)
 751 {
 752     struct msg_queue *queue = current->queue;
 753     if (queue)
 754     {
 755         reply->wake_bits    = queue->wake_bits;
 756         reply->changed_bits = queue->changed_bits;
 757         if (req->clear) queue->changed_bits = 0;
 758     }
 759     else reply->wake_bits = reply->changed_bits = 0;
 760 }
 761
 762
 763 /* send a message to a thread queue */
 764 DECL_HANDLER(send_message)
 765 {
 766     struct message *msg;
 767     struct msg_queue *send_queue = get_current_queue();
 768     struct msg_queue *recv_queue;
 769     struct thread *thread = get_thread_from_id( req->id );
 770
 771     if (!thread) return;
 772
 773     if (!(recv_queue = thread->queue))
 774     {
 775         set_error( STATUS_INVALID_PARAMETER );
 776         release_object( thread );
 777         return;
 778     }
 779
 780     if ((msg = mem_alloc( sizeof(*msg) )))
 781     {
 782         msg->type      = req->type;
 783         msg->win       = get_user_full_handle( req->win );
 784         msg->msg       = req->msg;
 785         msg->wparam    = req->wparam;
 786         msg->lparam    = req->lparam;
 787         msg->time      = req->time;
 788         msg->x         = req->x;
 789         msg->y         = req->y;
 790         msg->info      = req->info;
 791         msg->result    = NULL;
 792         msg->data      = NULL;
 793         msg->data_size = 0;
 794
 795         switch(msg->type)
 796         {
 797         case MSG_OTHER_PROCESS:
 798             msg->data_size = get_req_data_size();
 799             if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
 800             {
 801                 free( msg );
 802                 break;
 803             }
 804             /* fall through */
 805         case MSG_ASCII:
 806         case MSG_UNICODE:
 807         case MSG_CALLBACK:
 808             if (!(msg->result = alloc_message_result( send_queue, recv_queue, req->timeout )))
 809             {
 810                 free( msg );
 811                 break;
 812             }
 813             /* fall through */
 814         case MSG_NOTIFY:
 815             append_message( &recv_queue->msg_list[SEND_MESSAGE], msg );
 816             set_queue_bits( recv_queue, QS_SENDMESSAGE );
 817             break;
 818         case MSG_POSTED:
 819             /* needed for posted DDE messages */
 820             msg->data_size = get_req_data_size();
 821             if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
 822             {
 823                 free( msg );
 824                 break;
 825             }
 826             append_message( &recv_queue->msg_list[POST_MESSAGE], msg );
 827             set_queue_bits( recv_queue, QS_POSTMESSAGE );
 828             break;
 829         case MSG_HARDWARE_RAW:
 830         case MSG_HARDWARE_COOKED:
 831             {
 832                 struct message_list *list = ((msg->type == MSG_HARDWARE_RAW) ?
 833                                              &recv_queue->msg_list[RAW_HW_MESSAGE] :
 834                                              &recv_queue->msg_list[COOKED_HW_MESSAGE]);
 835                 if (msg->msg == WM_MOUSEMOVE && merge_message( list, msg ))
 836                 {
 837                     free( msg );
 838                     break;
 839                 }
 840                 append_message( list, msg );
 841                 set_queue_bits( recv_queue, get_hardware_msg_bit(msg) );
 842                 break;
 843             }
 844         default:
 845             set_error( STATUS_INVALID_PARAMETER );
 846             free( msg );
 847             break;
 848         }
 849     }
 850     release_object( thread );
 851 }
 852
 853 /* return a message to the application, removing it from the queue if needed */
 854 static void return_message_to_app( struct msg_queue *queue, int flags,
 855                                    struct get_message_reply *reply,
 856                                    struct message *msg, enum message_kind kind )
 857 {
 858     reply->total = msg->data_size;
 859     if (msg->data_size > get_reply_max_size())
 860     {
 861         set_error( STATUS_BUFFER_OVERFLOW );
 862         return;
 863     }
 864     reply->type   = msg->type;
 865     reply->win    = msg->win;
 866     reply->msg    = msg->msg;
 867     reply->wparam = msg->wparam;
 868     reply->lparam = msg->lparam;
 869     reply->x      = msg->x;
 870     reply->y      = msg->y;
 871     reply->time   = msg->time;
 872     reply->info   = msg->info;
 873
 874     /* raw messages always get removed */
 875     if ((msg->type == MSG_HARDWARE_RAW) || (flags & GET_MSG_REMOVE))
 876     {
 877         queue->last_msg = NULL;
 878         if (msg->data)
 879         {
 880             set_reply_data_ptr( msg->data, msg->data_size );
 881             msg->data = NULL;
 882             msg->data_size = 0;
 883         }
 884         remove_queue_message( queue, msg, kind );
 885     }
 886     else  /* remember it as the last returned message */
 887     {
 888         if (msg->data) set_reply_data( msg->data, msg->data_size );
 889         queue->last_msg = msg;
 890         queue->last_msg_kind = kind;
 891     }
 892 }
 893
 894
 895 inline static struct message *find_matching_message( const struct message_list *list,
 896                                                      user_handle_t win,
 897                                                      unsigned int first, unsigned int last )
 898 {
 899     struct message *msg;
 900
 901     for (msg = list->first; msg; msg = msg->next)
 902     {
 903         /* check against the filters */
 904         if (msg->msg == WM_QUIT) break;  /* WM_QUIT is never filtered */
 905         if (win && msg->win && msg->win != win && !is_child_window( win, msg->win )) continue;
 906         if (msg->msg < first) continue;
 907         if (msg->msg > last) continue;
 908         break; /* found one */
 909     }
 910     return msg;
 911 }
 912
 913
 914 /* get a message from the current queue */
 915 DECL_HANDLER(get_message)
 916 {
 917     struct timer *timer;
 918     struct message *msg;
 919     struct msg_queue *queue = get_current_queue();
 920     user_handle_t get_win = get_user_full_handle( req->get_win );
 921
 922     if (!queue) return;
 923
 924     /* first check for sent messages */
 925     if ((msg = queue->msg_list[SEND_MESSAGE].first))
 926     {
 927         receive_message( queue, msg, reply );
 928         return;
 929     }
 930     if (req->flags & GET_MSG_SENT_ONLY) goto done;  /* nothing else to check */
 931
 932     /* if requested, remove the last returned but not yet removed message */
 933     if ((req->flags & GET_MSG_REMOVE_LAST) && queue->last_msg)
 934         remove_queue_message( queue, queue->last_msg, queue->last_msg_kind );
 935     queue->last_msg = NULL;
 936
 937     /* clear changed bits so we can wait on them if we don't find a message */
 938     queue->changed_bits = 0;
 939
 940     /* then check for posted messages */
 941     if ((msg = find_matching_message( &queue->msg_list[POST_MESSAGE], get_win,
 942                                       req->get_first, req->get_last )))
 943     {
 944         return_message_to_app( queue, req->flags, reply, msg, POST_MESSAGE );
 945         return;
 946     }
 947
 948     /* then check for cooked hardware messages */
 949     if ((msg = find_matching_message( &queue->msg_list[COOKED_HW_MESSAGE], get_win,
 950                                       req->get_first, req->get_last )))
 951     {
 952         return_message_to_app( queue, req->flags, reply, msg, COOKED_HW_MESSAGE );
 953         return;
 954     }
 955
 956     /* then check for any raw hardware message */
 957     if ((msg = queue->msg_list[RAW_HW_MESSAGE].first))
 958     {
 959         return_message_to_app( queue, req->flags, reply, msg, RAW_HW_MESSAGE );
 960         return;
 961     }
 962
 963     /* now check for WM_PAINT */
 964     if (queue->paint_count &&
 965         (WM_PAINT >= req->get_first) && (WM_PAINT <= req->get_last) &&
 966         (reply->win = find_window_to_repaint( get_win, current )))
 967     {
 968         reply->type   = MSG_POSTED;
 969         reply->msg    = WM_PAINT;
 970         reply->wparam = 0;
 971         reply->lparam = 0;
 972         reply->x      = 0;
 973         reply->y      = 0;
 974         reply->time   = get_tick_count();
 975         reply->info   = 0;
 976         return;
 977     }
 978
 979     /* now check for timer */
 980     if ((timer = find_expired_timer( queue, get_win, req->get_first,
 981                                      req->get_last, (req->flags & GET_MSG_REMOVE) )))
 982     {
 983         reply->type   = MSG_POSTED;
 984         reply->win    = timer->win;
 985         reply->msg    = timer->msg;
 986         reply->wparam = timer->id;
 987         reply->lparam = timer->lparam;
 988         reply->x      = 0;
 989         reply->y      = 0;
 990         reply->time   = get_tick_count();
 991         reply->info   = 0;
 992         return;
 993     }
 994
 995  done:
 996     set_error( STATUS_PENDING );  /* FIXME */
 997 }
 998
 999
1000 /* reply to a sent message */
1001 DECL_HANDLER(reply_message)
1002 {
1003     if (current->queue && current->queue->recv_result)
1004         reply_message( current->queue, req->result, 0, req->remove,
1005                        get_req_data(), get_req_data_size() );
1006     else
1007         set_error( STATUS_ACCESS_DENIED );
1008 }
1009
1010
1011 /* retrieve the reply for the last message sent */
1012 DECL_HANDLER(get_message_reply)
1013 {
1014     struct msg_queue *queue = current->queue;
1015
1016     if (queue)
1017     {
1018         struct message_result *result = queue->send_result;
1019
1020         set_error( STATUS_PENDING );
1021         reply->result = 0;
1022
1023         if (result && (result->replied || req->cancel))
1024         {
1025             if (result->replied)
1026             {
1027                 reply->result = result->result;
1028                 set_error( result->error );
1029                 if (result->data)
1030                 {
1031                     size_t data_len = min( result->data_size, get_reply_max_size() );
1032                     set_reply_data_ptr( result->data, data_len );
1033                     result->data = NULL;
1034                     result->data_size = 0;
1035                 }
1036             }
1037             queue->send_result = result->send_next;
1038             result->sender = NULL;
1039             if (!result->receiver) free_result( result );
1040             if (!queue->send_result || !queue->send_result->replied)
1041                 clear_queue_bits( queue, QS_SMRESULT );
1042         }
1043     }
1044     else set_error( STATUS_ACCESS_DENIED );
1045 }
1046
1047
1048 /* set a window timer */
1049 DECL_HANDLER(set_win_timer)
1050 {
1051     struct timer *timer;
1052     struct msg_queue *queue = get_current_queue();
1053     user_handle_t win = get_user_full_handle( req->win );
1054
1055     if (!queue) return;
1056
1057     /* remove it if it existed already */
1058     if (win) kill_timer( queue, win, req->msg, req->id );
1059
1060     if ((timer = set_timer( queue, req->rate )))
1061     {
1062         timer->win    = win;
1063         timer->msg    = req->msg;
1064         timer->id     = req->id;
1065         timer->lparam = req->lparam;
1066     }
1067 }
1068
1069 /* kill a window timer */
1070 DECL_HANDLER(kill_win_timer)
1071 {
1072     struct msg_queue *queue = current->queue;
1073
1074     if (!queue || !kill_timer( queue, get_user_full_handle(req->win), req->msg, req->id ))
1075         set_error( STATUS_INVALID_PARAMETER );
1076 }