Sync with trunk r58740.
[reactos.git] / ntoskrnl / lpc / send.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/lpc/send.c
5 * PURPOSE: Local Procedure Call: Sending (Requests)
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* PUBLIC FUNCTIONS **********************************************************/
16
17 /*
18 * @implemented
19 */
20 NTSTATUS
21 NTAPI
22 LpcRequestPort(IN PVOID PortObject,
23 IN PPORT_MESSAGE LpcMessage)
24 {
25 PLPCP_PORT_OBJECT Port = PortObject, QueuePort, ConnectionPort = NULL;
26 ULONG MessageType;
27 PLPCP_MESSAGE Message;
28 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
29 PAGED_CODE();
30 LPCTRACE(LPC_SEND_DEBUG, "Port: %p. Message: %p\n", Port, LpcMessage);
31
32 /* Check if this is a non-datagram message */
33 if (LpcMessage->u2.s2.Type)
34 {
35 /* Get the message type */
36 MessageType = LpcpGetMessageType(LpcMessage);
37
38 /* Validate it */
39 if ((MessageType < LPC_DATAGRAM) || (MessageType > LPC_CLIENT_DIED))
40 {
41 /* Fail */
42 return STATUS_INVALID_PARAMETER;
43 }
44
45 /* Mark this as a kernel-mode message only if we really came from it */
46 if ((PreviousMode == KernelMode) &&
47 (LpcMessage->u2.s2.Type & LPC_KERNELMODE_MESSAGE))
48 {
49 /* We did, this is a kernel mode message */
50 MessageType |= LPC_KERNELMODE_MESSAGE;
51 }
52 }
53 else
54 {
55 /* This is a datagram */
56 MessageType = LPC_DATAGRAM;
57 }
58
59 /* Can't have data information on this type of call */
60 if (LpcMessage->u2.s2.DataInfoOffset) return STATUS_INVALID_PARAMETER;
61
62 /* Validate message sizes */
63 if (((ULONG)LpcMessage->u1.s1.TotalLength > Port->MaxMessageLength) ||
64 ((ULONG)LpcMessage->u1.s1.TotalLength <= (ULONG)LpcMessage->u1.s1.DataLength))
65 {
66 /* Fail */
67 return STATUS_PORT_MESSAGE_TOO_LONG;
68 }
69
70 /* Allocate a new message */
71 Message = LpcpAllocateFromPortZone();
72 if (!Message) return STATUS_NO_MEMORY;
73
74 /* Clear the context */
75 Message->RepliedToThread = NULL;
76 Message->PortContext = NULL;
77
78 /* Copy the message */
79 LpcpMoveMessage(&Message->Request,
80 LpcMessage,
81 LpcMessage + 1,
82 MessageType,
83 &PsGetCurrentThread()->Cid);
84
85 /* Acquire the LPC lock */
86 KeAcquireGuardedMutex(&LpcpLock);
87
88 /* Check if this is anything but a connection port */
89 if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT)
90 {
91 /* The queue port is the connected port */
92 QueuePort = Port->ConnectedPort;
93 if (QueuePort)
94 {
95 /* Check if this is a client port */
96 if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT)
97 {
98 /* Then copy the context */
99 Message->PortContext = QueuePort->PortContext;
100 ConnectionPort = QueuePort = Port->ConnectionPort;
101 if (!ConnectionPort)
102 {
103 /* Fail */
104 LpcpFreeToPortZone(Message, 3);
105 return STATUS_PORT_DISCONNECTED;
106 }
107 }
108 else if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_COMMUNICATION_PORT)
109 {
110 /* Any other kind of port, use the connection port */
111 ConnectionPort = QueuePort = Port->ConnectionPort;
112 if (!ConnectionPort)
113 {
114 /* Fail */
115 LpcpFreeToPortZone(Message, 3);
116 return STATUS_PORT_DISCONNECTED;
117 }
118 }
119
120 /* If we have a connection port, reference it */
121 if (ConnectionPort) ObReferenceObject(ConnectionPort);
122 }
123 }
124 else
125 {
126 /* For connection ports, use the port itself */
127 QueuePort = PortObject;
128 }
129
130 /* Make sure we have a port */
131 if (QueuePort)
132 {
133 /* Generate the Message ID and set it */
134 Message->Request.MessageId = LpcpNextMessageId++;
135 if (!LpcpNextMessageId) LpcpNextMessageId = 1;
136 Message->Request.CallbackId = 0;
137
138 /* No Message ID for the thread */
139 PsGetCurrentThread()->LpcReplyMessageId = 0;
140
141 /* Insert the message in our chain */
142 InsertTailList(&QueuePort->MsgQueue.ReceiveHead, &Message->Entry);
143
144 /* Release the lock and release the semaphore */
145 KeEnterCriticalRegion();
146 KeReleaseGuardedMutex(&LpcpLock);
147 LpcpCompleteWait(QueuePort->MsgQueue.Semaphore);
148
149 /* If this is a waitable port, wake it up */
150 if (QueuePort->Flags & LPCP_WAITABLE_PORT)
151 {
152 /* Wake it */
153 KeSetEvent(&QueuePort->WaitEvent, IO_NO_INCREMENT, FALSE);
154 }
155
156 /* We're done */
157 KeLeaveCriticalRegion();
158 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
159 LPCTRACE(LPC_SEND_DEBUG, "Port: %p. Message: %p\n", QueuePort, Message);
160 return STATUS_SUCCESS;
161 }
162
163 /* If we got here, then free the message and fail */
164 LpcpFreeToPortZone(Message, 3);
165 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
166 return STATUS_PORT_DISCONNECTED;
167 }
168
169 /*
170 * @implemented
171 */
172 NTSTATUS
173 NTAPI
174 LpcRequestWaitReplyPort(IN PVOID PortObject,
175 IN PPORT_MESSAGE LpcRequest,
176 OUT PPORT_MESSAGE LpcReply)
177 {
178 PLPCP_PORT_OBJECT Port, QueuePort, ReplyPort, ConnectionPort = NULL;
179 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
180 NTSTATUS Status = STATUS_SUCCESS;
181 PLPCP_MESSAGE Message;
182 PETHREAD Thread = PsGetCurrentThread();
183 BOOLEAN Callback = FALSE;
184 PKSEMAPHORE Semaphore;
185 USHORT MessageType;
186 PAGED_CODE();
187
188 Port = (PLPCP_PORT_OBJECT)PortObject;
189
190 LPCTRACE(LPC_SEND_DEBUG,
191 "Port: %p. Messages: %p/%p. Type: %lx\n",
192 Port,
193 LpcRequest,
194 LpcReply,
195 LpcpGetMessageType(LpcRequest));
196
197 /* Check if the thread is dying */
198 if (Thread->LpcExitThreadCalled) return STATUS_THREAD_IS_TERMINATING;
199
200 /* Check if this is an LPC Request */
201 MessageType = LpcpGetMessageType(LpcRequest);
202 switch (MessageType)
203 {
204 /* No type */
205 case 0:
206
207 /* Assume LPC request */
208 MessageType = LPC_REQUEST;
209 break;
210
211 /* LPC request callback */
212 case LPC_REQUEST:
213
214 /* This is a callback */
215 Callback = TRUE;
216 break;
217
218 /* Anything else */
219 case LPC_CLIENT_DIED:
220 case LPC_PORT_CLOSED:
221 case LPC_EXCEPTION:
222 case LPC_DEBUG_EVENT:
223 case LPC_ERROR_EVENT:
224
225 /* Nothing to do */
226 break;
227
228 default:
229
230 /* Invalid message type */
231 return STATUS_INVALID_PARAMETER;
232 }
233
234 /* Set the request type */
235 LpcRequest->u2.s2.Type = MessageType;
236
237 /* Validate the message length */
238 if (((ULONG)LpcRequest->u1.s1.TotalLength > Port->MaxMessageLength) ||
239 ((ULONG)LpcRequest->u1.s1.TotalLength <= (ULONG)LpcRequest->u1.s1.DataLength))
240 {
241 /* Fail */
242 return STATUS_PORT_MESSAGE_TOO_LONG;
243 }
244
245 /* Allocate a message from the port zone */
246 Message = LpcpAllocateFromPortZone();
247 if (!Message)
248 {
249 /* Fail if we couldn't allocate a message */
250 return STATUS_NO_MEMORY;
251 }
252
253 /* Check if this is a callback */
254 if (Callback)
255 {
256 /* FIXME: TODO */
257 Semaphore = NULL; // we'd use the Thread Semaphore here
258 ASSERT(FALSE);
259 return STATUS_NOT_IMPLEMENTED;
260 }
261 else
262 {
263 /* No callback, just copy the message */
264 LpcpMoveMessage(&Message->Request,
265 LpcRequest,
266 LpcRequest + 1,
267 0,
268 &Thread->Cid);
269
270 /* Acquire the LPC lock */
271 KeAcquireGuardedMutex(&LpcpLock);
272
273 /* Right now clear the port context */
274 Message->PortContext = NULL;
275
276 /* Check if this is a not connection port */
277 if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT)
278 {
279 /* We want the connected port */
280 QueuePort = Port->ConnectedPort;
281 if (!QueuePort)
282 {
283 /* We have no connected port, fail */
284 LpcpFreeToPortZone(Message, 3);
285 return STATUS_PORT_DISCONNECTED;
286 }
287
288 /* This will be the rundown port */
289 ReplyPort = QueuePort;
290
291 /* Check if this is a communication port */
292 if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT)
293 {
294 /* Copy the port context and use the connection port */
295 Message->PortContext = QueuePort->PortContext;
296 ConnectionPort = QueuePort = Port->ConnectionPort;
297 if (!ConnectionPort)
298 {
299 /* Fail */
300 LpcpFreeToPortZone(Message, 3);
301 return STATUS_PORT_DISCONNECTED;
302 }
303 }
304 else if ((Port->Flags & LPCP_PORT_TYPE_MASK) !=
305 LPCP_COMMUNICATION_PORT)
306 {
307 /* Use the connection port for anything but communication ports */
308 ConnectionPort = QueuePort = Port->ConnectionPort;
309 if (!ConnectionPort)
310 {
311 /* Fail */
312 LpcpFreeToPortZone(Message, 3);
313 return STATUS_PORT_DISCONNECTED;
314 }
315 }
316
317 /* Reference the connection port if it exists */
318 if (ConnectionPort) ObReferenceObject(ConnectionPort);
319 }
320 else
321 {
322 /* Otherwise, for a connection port, use the same port object */
323 QueuePort = ReplyPort = Port;
324 }
325
326 /* No reply thread */
327 Message->RepliedToThread = NULL;
328 Message->SenderPort = Port;
329
330 /* Generate the Message ID and set it */
331 Message->Request.MessageId = LpcpNextMessageId++;
332 if (!LpcpNextMessageId) LpcpNextMessageId = 1;
333 Message->Request.CallbackId = 0;
334
335 /* Set the message ID for our thread now */
336 Thread->LpcReplyMessageId = Message->Request.MessageId;
337 Thread->LpcReplyMessage = NULL;
338
339 /* Insert the message in our chain */
340 InsertTailList(&QueuePort->MsgQueue.ReceiveHead, &Message->Entry);
341 InsertTailList(&ReplyPort->LpcReplyChainHead, &Thread->LpcReplyChain);
342 LpcpSetPortToThread(Thread, Port);
343
344 /* Release the lock and get the semaphore we'll use later */
345 KeEnterCriticalRegion();
346 KeReleaseGuardedMutex(&LpcpLock);
347 Semaphore = QueuePort->MsgQueue.Semaphore;
348
349 /* If this is a waitable port, wake it up */
350 if (QueuePort->Flags & LPCP_WAITABLE_PORT)
351 {
352 /* Wake it */
353 KeSetEvent(&QueuePort->WaitEvent, IO_NO_INCREMENT, FALSE);
354 }
355 }
356
357 /* Now release the semaphore */
358 LpcpCompleteWait(Semaphore);
359 KeLeaveCriticalRegion();
360
361 /* And let's wait for the reply */
362 LpcpReplyWait(&Thread->LpcReplySemaphore, PreviousMode);
363
364 /* Acquire the LPC lock */
365 KeAcquireGuardedMutex(&LpcpLock);
366
367 /* Get the LPC Message and clear our thread's reply data */
368 Message = LpcpGetMessageFromThread(Thread);
369 Thread->LpcReplyMessage = NULL;
370 Thread->LpcReplyMessageId = 0;
371
372 /* Check if we have anything on the reply chain*/
373 if (!IsListEmpty(&Thread->LpcReplyChain))
374 {
375 /* Remove this thread and reinitialize the list */
376 RemoveEntryList(&Thread->LpcReplyChain);
377 InitializeListHead(&Thread->LpcReplyChain);
378 }
379
380 /* Release the lock */
381 KeReleaseGuardedMutex(&LpcpLock);
382
383 /* Check if we got a reply */
384 if (Status == STATUS_SUCCESS)
385 {
386 /* Check if we have a valid message */
387 if (Message)
388 {
389 LPCTRACE(LPC_SEND_DEBUG,
390 "Reply Messages: %p/%p\n",
391 &Message->Request,
392 (&Message->Request) + 1);
393
394 /* Move the message */
395 LpcpMoveMessage(LpcReply,
396 &Message->Request,
397 (&Message->Request) + 1,
398 0,
399 NULL);
400
401 /* Acquire the lock */
402 KeAcquireGuardedMutex(&LpcpLock);
403
404 /* Check if we replied to a thread */
405 if (Message->RepliedToThread)
406 {
407 /* Dereference */
408 ObDereferenceObject(Message->RepliedToThread);
409 Message->RepliedToThread = NULL;
410 }
411
412
413 /* Free the message */
414 LpcpFreeToPortZone(Message, 3);
415 }
416 else
417 {
418 /* We don't have a reply */
419 Status = STATUS_LPC_REPLY_LOST;
420 }
421 }
422 else
423 {
424 /* The wait failed, free the message */
425 if (Message) LpcpFreeToPortZone(Message, 0);
426 }
427
428 /* All done */
429 LPCTRACE(LPC_SEND_DEBUG,
430 "Port: %p. Status: %p\n",
431 Port,
432 Status);
433
434 /* Dereference the connection port */
435 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
436 return Status;
437 }
438
439 /*
440 * @implemented
441 */
442 NTSTATUS
443 NTAPI
444 NtRequestPort(IN HANDLE PortHandle,
445 IN PPORT_MESSAGE LpcRequest)
446 {
447 PLPCP_PORT_OBJECT Port, QueuePort, ConnectionPort = NULL;
448 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
449 NTSTATUS Status;
450 PLPCP_MESSAGE Message;
451 PETHREAD Thread = PsGetCurrentThread();
452
453 PKSEMAPHORE Semaphore;
454 ULONG MessageType;
455 PAGED_CODE();
456 LPCTRACE(LPC_SEND_DEBUG,
457 "Handle: %lx. Message: %p. Type: %lx\n",
458 PortHandle,
459 LpcRequest,
460 LpcpGetMessageType(LpcRequest));
461
462 /* Get the message type */
463 MessageType = LpcRequest->u2.s2.Type | LPC_DATAGRAM;
464
465 /* Can't have data information on this type of call */
466 if (LpcRequest->u2.s2.DataInfoOffset) return STATUS_INVALID_PARAMETER;
467
468 /* Validate the length */
469 if (((ULONG)LpcRequest->u1.s1.DataLength + sizeof(PORT_MESSAGE)) >
470 (ULONG)LpcRequest->u1.s1.TotalLength)
471 {
472 /* Fail */
473 return STATUS_INVALID_PARAMETER;
474 }
475
476 /* Reference the object */
477 Status = ObReferenceObjectByHandle(PortHandle,
478 0,
479 LpcPortObjectType,
480 PreviousMode,
481 (PVOID*)&Port,
482 NULL);
483 if (!NT_SUCCESS(Status)) return Status;
484
485 /* Validate the message length */
486 if (((ULONG)LpcRequest->u1.s1.TotalLength > Port->MaxMessageLength) ||
487 ((ULONG)LpcRequest->u1.s1.TotalLength <= (ULONG)LpcRequest->u1.s1.DataLength))
488 {
489 /* Fail */
490 ObDereferenceObject(Port);
491 return STATUS_PORT_MESSAGE_TOO_LONG;
492 }
493
494 /* Allocate a message from the port zone */
495 Message = LpcpAllocateFromPortZone();
496 if (!Message)
497 {
498 /* Fail if we couldn't allocate a message */
499 ObDereferenceObject(Port);
500 return STATUS_NO_MEMORY;
501 }
502
503 /* No callback, just copy the message */
504 _SEH2_TRY
505 {
506 /* Copy it */
507 LpcpMoveMessage(&Message->Request,
508 LpcRequest,
509 LpcRequest + 1,
510 MessageType,
511 &Thread->Cid);
512 }
513 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
514 {
515 /* Fail */
516 LpcpFreeToPortZone(Message, 0);
517 ObDereferenceObject(Port);
518 _SEH2_YIELD(return _SEH2_GetExceptionCode());
519 }
520 _SEH2_END;
521
522 /* Acquire the LPC lock */
523 KeAcquireGuardedMutex(&LpcpLock);
524
525 /* Right now clear the port context */
526 Message->PortContext = NULL;
527
528 /* Check if this is a not connection port */
529 if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT)
530 {
531 /* We want the connected port */
532 QueuePort = Port->ConnectedPort;
533 if (!QueuePort)
534 {
535 /* We have no connected port, fail */
536 LpcpFreeToPortZone(Message, 3);
537 ObDereferenceObject(Port);
538 return STATUS_PORT_DISCONNECTED;
539 }
540
541 /* Check if this is a communication port */
542 if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT)
543 {
544 /* Copy the port context and use the connection port */
545 Message->PortContext = QueuePort->PortContext;
546 ConnectionPort = QueuePort = Port->ConnectionPort;
547 if (!ConnectionPort)
548 {
549 /* Fail */
550 LpcpFreeToPortZone(Message, 3);
551 ObDereferenceObject(Port);
552 return STATUS_PORT_DISCONNECTED;
553 }
554 }
555 else if ((Port->Flags & LPCP_PORT_TYPE_MASK) !=
556 LPCP_COMMUNICATION_PORT)
557 {
558 /* Use the connection port for anything but communication ports */
559 ConnectionPort = QueuePort = Port->ConnectionPort;
560 if (!ConnectionPort)
561 {
562 /* Fail */
563 LpcpFreeToPortZone(Message, 3);
564 ObDereferenceObject(Port);
565 return STATUS_PORT_DISCONNECTED;
566 }
567 }
568
569 /* Reference the connection port if it exists */
570 if (ConnectionPort) ObReferenceObject(ConnectionPort);
571 }
572 else
573 {
574 /* Otherwise, for a connection port, use the same port object */
575 QueuePort = Port;
576 }
577
578 /* Reference QueuePort if we have it */
579 if (QueuePort && ObReferenceObjectSafe(QueuePort))
580 {
581 /* Set sender's port */
582 Message->SenderPort = Port;
583
584 /* Generate the Message ID and set it */
585 Message->Request.MessageId = LpcpNextMessageId++;
586 if (!LpcpNextMessageId) LpcpNextMessageId = 1;
587 Message->Request.CallbackId = 0;
588
589 /* No Message ID for the thread */
590 PsGetCurrentThread()->LpcReplyMessageId = 0;
591
592 /* Insert the message in our chain */
593 InsertTailList(&QueuePort->MsgQueue.ReceiveHead, &Message->Entry);
594
595 /* Release the lock and get the semaphore we'll use later */
596 KeEnterCriticalRegion();
597 KeReleaseGuardedMutex(&LpcpLock);
598
599 /* Now release the semaphore */
600 Semaphore = QueuePort->MsgQueue.Semaphore;
601 LpcpCompleteWait(Semaphore);
602
603 /* If this is a waitable port, wake it up */
604 if (QueuePort->Flags & LPCP_WAITABLE_PORT)
605 {
606 /* Wake it */
607 KeSetEvent(&QueuePort->WaitEvent, IO_NO_INCREMENT, FALSE);
608 }
609
610 KeLeaveCriticalRegion();
611
612 /* Dereference objects */
613 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
614 ObDereferenceObject(QueuePort);
615 ObDereferenceObject(Port);
616 LPCTRACE(LPC_SEND_DEBUG, "Port: %p. Message: %p\n", QueuePort, Message);
617 return STATUS_SUCCESS;
618 }
619
620 Status = STATUS_PORT_DISCONNECTED;
621
622 /* All done with a failure*/
623 LPCTRACE(LPC_SEND_DEBUG,
624 "Port: %p. Status: %p\n",
625 Port,
626 Status);
627
628 /* The wait failed, free the message */
629 if (Message) LpcpFreeToPortZone(Message, 3);
630
631 ObDereferenceObject(Port);
632 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
633 return Status;
634 }
635
636 /*
637 * @implemented
638 */
639 NTSTATUS
640 NTAPI
641 NtRequestWaitReplyPort(IN HANDLE PortHandle,
642 IN PPORT_MESSAGE LpcRequest,
643 IN OUT PPORT_MESSAGE LpcReply)
644 {
645 PLPCP_PORT_OBJECT Port, QueuePort, ReplyPort, ConnectionPort = NULL;
646 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
647 NTSTATUS Status;
648 PLPCP_MESSAGE Message;
649 PETHREAD Thread = PsGetCurrentThread();
650 BOOLEAN Callback;
651 PKSEMAPHORE Semaphore;
652 ULONG MessageType;
653 PAGED_CODE();
654 LPCTRACE(LPC_SEND_DEBUG,
655 "Handle: %lx. Messages: %p/%p. Type: %lx\n",
656 PortHandle,
657 LpcRequest,
658 LpcReply,
659 LpcpGetMessageType(LpcRequest));
660
661 /* Check if the thread is dying */
662 if (Thread->LpcExitThreadCalled) return STATUS_THREAD_IS_TERMINATING;
663
664 /* Check if this is an LPC Request */
665 if (LpcpGetMessageType(LpcRequest) == LPC_REQUEST)
666 {
667 /* Then it's a callback */
668 Callback = TRUE;
669 }
670 else if (LpcpGetMessageType(LpcRequest))
671 {
672 /* This is a not kernel-mode message */
673 return STATUS_INVALID_PARAMETER;
674 }
675 else
676 {
677 /* This is a kernel-mode message without a callback */
678 LpcRequest->u2.s2.Type |= LPC_REQUEST;
679 Callback = FALSE;
680 }
681
682 /* Get the message type */
683 MessageType = LpcRequest->u2.s2.Type;
684
685 /* Validate the length */
686 if (((ULONG)LpcRequest->u1.s1.DataLength + sizeof(PORT_MESSAGE)) >
687 (ULONG)LpcRequest->u1.s1.TotalLength)
688 {
689 /* Fail */
690 return STATUS_INVALID_PARAMETER;
691 }
692
693 /* Reference the object */
694 Status = ObReferenceObjectByHandle(PortHandle,
695 0,
696 LpcPortObjectType,
697 PreviousMode,
698 (PVOID*)&Port,
699 NULL);
700 if (!NT_SUCCESS(Status)) return Status;
701
702 /* Validate the message length */
703 if (((ULONG)LpcRequest->u1.s1.TotalLength > Port->MaxMessageLength) ||
704 ((ULONG)LpcRequest->u1.s1.TotalLength <= (ULONG)LpcRequest->u1.s1.DataLength))
705 {
706 /* Fail */
707 ObDereferenceObject(Port);
708 return STATUS_PORT_MESSAGE_TOO_LONG;
709 }
710
711 /* Allocate a message from the port zone */
712 Message = LpcpAllocateFromPortZone();
713 if (!Message)
714 {
715 /* Fail if we couldn't allocate a message */
716 ObDereferenceObject(Port);
717 return STATUS_NO_MEMORY;
718 }
719
720 /* Check if this is a callback */
721 if (Callback)
722 {
723 /* FIXME: TODO */
724 Semaphore = NULL; // we'd use the Thread Semaphore here
725 ASSERT(FALSE);
726 }
727 else
728 {
729 /* No callback, just copy the message */
730 _SEH2_TRY
731 {
732 /* Copy it */
733 LpcpMoveMessage(&Message->Request,
734 LpcRequest,
735 LpcRequest + 1,
736 MessageType,
737 &Thread->Cid);
738 }
739 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
740 {
741 /* Fail */
742 LpcpFreeToPortZone(Message, 0);
743 ObDereferenceObject(Port);
744 _SEH2_YIELD(return _SEH2_GetExceptionCode());
745 }
746 _SEH2_END;
747
748 /* Acquire the LPC lock */
749 KeAcquireGuardedMutex(&LpcpLock);
750
751 /* Right now clear the port context */
752 Message->PortContext = NULL;
753
754 /* Check if this is a not connection port */
755 if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT)
756 {
757 /* We want the connected port */
758 QueuePort = Port->ConnectedPort;
759 if (!QueuePort)
760 {
761 /* We have no connected port, fail */
762 LpcpFreeToPortZone(Message, 3);
763 ObDereferenceObject(Port);
764 return STATUS_PORT_DISCONNECTED;
765 }
766
767 /* This will be the rundown port */
768 ReplyPort = QueuePort;
769
770 /* Check if this is a communication port */
771 if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT)
772 {
773 /* Copy the port context and use the connection port */
774 Message->PortContext = QueuePort->PortContext;
775 ConnectionPort = QueuePort = Port->ConnectionPort;
776 if (!ConnectionPort)
777 {
778 /* Fail */
779 LpcpFreeToPortZone(Message, 3);
780 ObDereferenceObject(Port);
781 return STATUS_PORT_DISCONNECTED;
782 }
783 }
784 else if ((Port->Flags & LPCP_PORT_TYPE_MASK) !=
785 LPCP_COMMUNICATION_PORT)
786 {
787 /* Use the connection port for anything but communication ports */
788 ConnectionPort = QueuePort = Port->ConnectionPort;
789 if (!ConnectionPort)
790 {
791 /* Fail */
792 LpcpFreeToPortZone(Message, 3);
793 ObDereferenceObject(Port);
794 return STATUS_PORT_DISCONNECTED;
795 }
796 }
797
798 /* Reference the connection port if it exists */
799 if (ConnectionPort) ObReferenceObject(ConnectionPort);
800 }
801 else
802 {
803 /* Otherwise, for a connection port, use the same port object */
804 QueuePort = ReplyPort = Port;
805 }
806
807 /* No reply thread */
808 Message->RepliedToThread = NULL;
809 Message->SenderPort = Port;
810
811 /* Generate the Message ID and set it */
812 Message->Request.MessageId = LpcpNextMessageId++;
813 if (!LpcpNextMessageId) LpcpNextMessageId = 1;
814 Message->Request.CallbackId = 0;
815
816 /* Set the message ID for our thread now */
817 Thread->LpcReplyMessageId = Message->Request.MessageId;
818 Thread->LpcReplyMessage = NULL;
819
820 /* Insert the message in our chain */
821 InsertTailList(&QueuePort->MsgQueue.ReceiveHead, &Message->Entry);
822 InsertTailList(&ReplyPort->LpcReplyChainHead, &Thread->LpcReplyChain);
823 LpcpSetPortToThread(Thread, Port);
824
825 /* Release the lock and get the semaphore we'll use later */
826 KeEnterCriticalRegion();
827 KeReleaseGuardedMutex(&LpcpLock);
828 Semaphore = QueuePort->MsgQueue.Semaphore;
829
830 /* If this is a waitable port, wake it up */
831 if (QueuePort->Flags & LPCP_WAITABLE_PORT)
832 {
833 /* Wake it */
834 KeSetEvent(&QueuePort->WaitEvent, IO_NO_INCREMENT, FALSE);
835 }
836 }
837
838 /* Now release the semaphore */
839 LpcpCompleteWait(Semaphore);
840 KeLeaveCriticalRegion();
841
842 /* And let's wait for the reply */
843 LpcpReplyWait(&Thread->LpcReplySemaphore, PreviousMode);
844
845 /* Acquire the LPC lock */
846 KeAcquireGuardedMutex(&LpcpLock);
847
848 /* Get the LPC Message and clear our thread's reply data */
849 Message = LpcpGetMessageFromThread(Thread);
850 Thread->LpcReplyMessage = NULL;
851 Thread->LpcReplyMessageId = 0;
852
853 /* Check if we have anything on the reply chain*/
854 if (!IsListEmpty(&Thread->LpcReplyChain))
855 {
856 /* Remove this thread and reinitialize the list */
857 RemoveEntryList(&Thread->LpcReplyChain);
858 InitializeListHead(&Thread->LpcReplyChain);
859 }
860
861 /* Release the lock */
862 KeReleaseGuardedMutex(&LpcpLock);
863
864 /* Check if we got a reply */
865 if (Status == STATUS_SUCCESS)
866 {
867 /* Check if we have a valid message */
868 if (Message)
869 {
870 LPCTRACE(LPC_SEND_DEBUG,
871 "Reply Messages: %p/%p\n",
872 &Message->Request,
873 (&Message->Request) + 1);
874
875 /* Move the message */
876 _SEH2_TRY
877 {
878 LpcpMoveMessage(LpcReply,
879 &Message->Request,
880 (&Message->Request) + 1,
881 0,
882 NULL);
883 }
884 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
885 {
886 Status = _SEH2_GetExceptionCode();
887 }
888 _SEH2_END;
889
890 /* Check if this is an LPC request with data information */
891 if ((LpcpGetMessageType(&Message->Request) == LPC_REQUEST) &&
892 (Message->Request.u2.s2.DataInfoOffset))
893 {
894 /* Save the data information */
895 LpcpSaveDataInfoMessage(Port, Message, 0);
896 }
897 else
898 {
899 /* Otherwise, just free it */
900 LpcpFreeToPortZone(Message, 0);
901 }
902 }
903 else
904 {
905 /* We don't have a reply */
906 Status = STATUS_LPC_REPLY_LOST;
907 }
908 }
909 else
910 {
911 /* The wait failed, free the message */
912 if (Message) LpcpFreeToPortZone(Message, 0);
913 }
914
915 /* All done */
916 LPCTRACE(LPC_SEND_DEBUG,
917 "Port: %p. Status: %p\n",
918 Port,
919 Status);
920 ObDereferenceObject(Port);
921 if (ConnectionPort) ObDereferenceObject(ConnectionPort);
922 return Status;
923 }
924
925 /* EOF */