[STORPORT] Fix x64 build
[reactos.git] / ntoskrnl / lpc / complete.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/lpc/complete.c
5 * PURPOSE: Local Procedure Call: Connection Completion
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 /* PRIVATE FUNCTIONS *********************************************************/
16
17 VOID
18 NTAPI
19 LpcpPrepareToWakeClient(IN PETHREAD Thread)
20 {
21 PAGED_CODE();
22
23 /* Make sure the thread isn't dying and it has a valid chain */
24 if (!(Thread->LpcExitThreadCalled) &&
25 !(IsListEmpty(&Thread->LpcReplyChain)))
26 {
27 /* Remove it from the list and reinitialize it */
28 RemoveEntryList(&Thread->LpcReplyChain);
29 InitializeListHead(&Thread->LpcReplyChain);
30 }
31 }
32
33 /* PUBLIC FUNCTIONS **********************************************************/
34
35 /*
36 * @implemented
37 */
38 NTSTATUS
39 NTAPI
40 NtAcceptConnectPort(OUT PHANDLE PortHandle,
41 IN PVOID PortContext OPTIONAL,
42 IN PPORT_MESSAGE ReplyMessage,
43 IN BOOLEAN AcceptConnection,
44 IN OUT PPORT_VIEW ServerView OPTIONAL,
45 OUT PREMOTE_PORT_VIEW ClientView OPTIONAL)
46 {
47 NTSTATUS Status;
48 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
49 PORT_VIEW CapturedServerView;
50 PORT_MESSAGE CapturedReplyMessage;
51 ULONG ConnectionInfoLength;
52 PLPCP_PORT_OBJECT ConnectionPort, ServerPort, ClientPort;
53 PLPCP_CONNECTION_MESSAGE ConnectMessage;
54 PLPCP_MESSAGE Message;
55 PVOID ClientSectionToMap = NULL;
56 HANDLE Handle;
57 PEPROCESS ClientProcess;
58 PETHREAD ClientThread;
59 LARGE_INTEGER SectionOffset;
60
61 PAGED_CODE();
62 LPCTRACE(LPC_COMPLETE_DEBUG,
63 "Context: %p. Message: %p. Accept: %lx. Views: %p/%p\n",
64 PortContext,
65 ReplyMessage,
66 AcceptConnection,
67 ClientView,
68 ServerView);
69
70 /* Check if the call comes from user mode */
71 if (PreviousMode != KernelMode)
72 {
73 _SEH2_TRY
74 {
75 /* Probe the PortHandle */
76 ProbeForWriteHandle(PortHandle);
77
78 /* Probe the basic ReplyMessage structure */
79 ProbeForRead(ReplyMessage, sizeof(*ReplyMessage), sizeof(ULONG));
80 CapturedReplyMessage = *(volatile PORT_MESSAGE*)ReplyMessage;
81 ConnectionInfoLength = CapturedReplyMessage.u1.s1.DataLength;
82
83 /* Probe the connection info */
84 ProbeForRead(ReplyMessage + 1, ConnectionInfoLength, 1);
85
86 /* The following parameters are optional */
87
88 /* Capture the server view */
89 if (ServerView)
90 {
91 ProbeForWrite(ServerView, sizeof(*ServerView), sizeof(ULONG));
92 CapturedServerView = *(volatile PORT_VIEW*)ServerView;
93
94 /* Validate the size of the server view */
95 if (CapturedServerView.Length != sizeof(CapturedServerView))
96 {
97 /* Invalid size */
98 _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
99 }
100 }
101
102 /* Capture the client view */
103 if (ClientView)
104 {
105 ProbeForWrite(ClientView, sizeof(*ClientView), sizeof(ULONG));
106
107 /* Validate the size of the client view */
108 if (((volatile REMOTE_PORT_VIEW*)ClientView)->Length != sizeof(*ClientView))
109 {
110 /* Invalid size */
111 _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
112 }
113 }
114 }
115 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
116 {
117 /* There was an exception, return the exception code */
118 _SEH2_YIELD(return _SEH2_GetExceptionCode());
119 }
120 _SEH2_END;
121 }
122 else
123 {
124 CapturedReplyMessage = *ReplyMessage;
125 ConnectionInfoLength = CapturedReplyMessage.u1.s1.DataLength;
126
127 /* Capture the server view */
128 if (ServerView)
129 {
130 /* Validate the size of the server view */
131 if (ServerView->Length != sizeof(*ServerView))
132 {
133 /* Invalid size */
134 return STATUS_INVALID_PARAMETER;
135 }
136 CapturedServerView = *ServerView;
137 }
138
139 /* Capture the client view */
140 if (ClientView)
141 {
142 /* Validate the size of the client view */
143 if (ClientView->Length != sizeof(*ClientView))
144 {
145 /* Invalid size */
146 return STATUS_INVALID_PARAMETER;
147 }
148 }
149 }
150
151 /* Get the client process and thread */
152 Status = PsLookupProcessThreadByCid(&CapturedReplyMessage.ClientId,
153 &ClientProcess,
154 &ClientThread);
155 if (!NT_SUCCESS(Status)) return Status;
156
157 /* Acquire the LPC Lock */
158 KeAcquireGuardedMutex(&LpcpLock);
159
160 /* Make sure that the client wants a reply, and this is the right one */
161 if (!(LpcpGetMessageFromThread(ClientThread)) ||
162 !(CapturedReplyMessage.MessageId) ||
163 (ClientThread->LpcReplyMessageId != CapturedReplyMessage.MessageId))
164 {
165 /* Not the reply asked for, or no reply wanted, fail */
166 KeReleaseGuardedMutex(&LpcpLock);
167 ObDereferenceObject(ClientProcess);
168 ObDereferenceObject(ClientThread);
169 return STATUS_REPLY_MESSAGE_MISMATCH;
170 }
171
172 /* Now get the message and connection message */
173 Message = LpcpGetMessageFromThread(ClientThread);
174 ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1);
175
176 /* Get the client and connection port as well */
177 ClientPort = ConnectMessage->ClientPort;
178 ConnectionPort = ClientPort->ConnectionPort;
179
180 /* Make sure that the reply is being sent to the proper server process */
181 if (ConnectionPort->ServerProcess != PsGetCurrentProcess())
182 {
183 /* It's not, so fail */
184 KeReleaseGuardedMutex(&LpcpLock);
185 ObDereferenceObject(ClientProcess);
186 ObDereferenceObject(ClientThread);
187 return STATUS_REPLY_MESSAGE_MISMATCH;
188 }
189
190 /* At this point, don't let other accept attempts happen */
191 ClientThread->LpcReplyMessage = NULL;
192 ClientThread->LpcReplyMessageId = 0;
193
194 /* Clear the client port for now as well, then release the lock */
195 ConnectMessage->ClientPort = NULL;
196 KeReleaseGuardedMutex(&LpcpLock);
197
198 /* Check the connection information length */
199 if (ConnectionInfoLength > ConnectionPort->MaxConnectionInfoLength)
200 {
201 /* Normalize it since it's too large */
202 ConnectionInfoLength = ConnectionPort->MaxConnectionInfoLength;
203 }
204
205 /* Set the sizes of our reply message */
206 Message->Request.u1.s1.DataLength = (CSHORT)ConnectionInfoLength +
207 sizeof(LPCP_CONNECTION_MESSAGE);
208 Message->Request.u1.s1.TotalLength = sizeof(LPCP_MESSAGE) +
209 Message->Request.u1.s1.DataLength;
210
211 /* Setup the reply message */
212 Message->Request.u2.s2.Type = LPC_REPLY;
213 Message->Request.u2.s2.DataInfoOffset = 0;
214 Message->Request.ClientId = CapturedReplyMessage.ClientId;
215 Message->Request.MessageId = CapturedReplyMessage.MessageId;
216 Message->Request.ClientViewSize = 0;
217
218 _SEH2_TRY
219 {
220 RtlCopyMemory(ConnectMessage + 1, ReplyMessage + 1, ConnectionInfoLength);
221 }
222 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
223 {
224 Status = _SEH2_GetExceptionCode();
225 _SEH2_YIELD(goto Cleanup);
226 }
227 _SEH2_END;
228
229 /* At this point, if the caller refused the connection, go to cleanup */
230 if (!AcceptConnection)
231 {
232 DPRINT1("LPC connection was refused\n");
233 goto Cleanup;
234 }
235
236 /* Otherwise, create the actual port */
237 Status = ObCreateObject(PreviousMode,
238 LpcPortObjectType,
239 NULL,
240 PreviousMode,
241 NULL,
242 sizeof(LPCP_PORT_OBJECT),
243 0,
244 0,
245 (PVOID*)&ServerPort);
246 if (!NT_SUCCESS(Status)) goto Cleanup;
247
248 /* Set it up */
249 RtlZeroMemory(ServerPort, sizeof(LPCP_PORT_OBJECT));
250 ServerPort->PortContext = PortContext;
251 ServerPort->Flags = LPCP_COMMUNICATION_PORT;
252 ServerPort->MaxMessageLength = ConnectionPort->MaxMessageLength;
253 InitializeListHead(&ServerPort->LpcReplyChainHead);
254 InitializeListHead(&ServerPort->LpcDataInfoChainHead);
255
256 /* Reference the connection port until we're fully setup */
257 ObReferenceObject(ConnectionPort);
258
259 /* Link the ports together */
260 ServerPort->ConnectionPort = ConnectionPort;
261 ServerPort->ConnectedPort = ClientPort;
262 ClientPort->ConnectedPort = ServerPort;
263
264 /* Also set the creator CID */
265 ServerPort->Creator = PsGetCurrentThread()->Cid;
266 ClientPort->Creator = Message->Request.ClientId;
267
268 /* Get the section associated and then clear it, while inside the lock */
269 KeAcquireGuardedMutex(&LpcpLock);
270 ClientSectionToMap = ConnectMessage->SectionToMap;
271 ConnectMessage->SectionToMap = NULL;
272 KeReleaseGuardedMutex(&LpcpLock);
273
274 /* Now check if there's a client section */
275 if (ClientSectionToMap)
276 {
277 /* Setup the offset */
278 SectionOffset.QuadPart = ConnectMessage->ClientView.SectionOffset;
279
280 /* Map the section */
281 Status = MmMapViewOfSection(ClientSectionToMap,
282 PsGetCurrentProcess(),
283 &ServerPort->ClientSectionBase,
284 0,
285 0,
286 &SectionOffset,
287 &ConnectMessage->ClientView.ViewSize,
288 ViewUnmap,
289 0,
290 PAGE_READWRITE);
291
292 /* Update the offset and check for mapping status */
293 ConnectMessage->ClientView.SectionOffset = SectionOffset.LowPart;
294 if (NT_SUCCESS(Status))
295 {
296 /* Set the view base */
297 ConnectMessage->ClientView.ViewRemoteBase = ServerPort->
298 ClientSectionBase;
299
300 /* Save and reference the mapping process */
301 ServerPort->MappingProcess = PsGetCurrentProcess();
302 ObReferenceObject(ServerPort->MappingProcess);
303 }
304 else
305 {
306 /* Otherwise, quit */
307 ObDereferenceObject(ServerPort);
308 DPRINT1("Client section mapping failed: %lx\n", Status);
309 DPRINT1("View base, offset, size: %p %lx %p\n",
310 ServerPort->ClientSectionBase,
311 ConnectMessage->ClientView.ViewSize,
312 SectionOffset);
313 goto Cleanup;
314 }
315 }
316
317 /* Check if there's a server section */
318 if (ServerView)
319 {
320 /* FIXME: TODO */
321 UNREFERENCED_PARAMETER(CapturedServerView);
322 ASSERT(FALSE);
323 }
324
325 /* Reference the server port until it's fully inserted */
326 ObReferenceObject(ServerPort);
327
328 /* Insert the server port in the namespace */
329 Status = ObInsertObject(ServerPort,
330 NULL,
331 PORT_ALL_ACCESS,
332 0,
333 NULL,
334 &Handle);
335 if (!NT_SUCCESS(Status))
336 {
337 /* We failed, remove the extra reference and cleanup */
338 ObDereferenceObject(ServerPort);
339 goto Cleanup;
340 }
341
342 /* Enter SEH to write back the results */
343 _SEH2_TRY
344 {
345 /* Check if the caller gave a client view */
346 if (ClientView)
347 {
348 /* Fill it out */
349 ClientView->ViewBase = ConnectMessage->ClientView.ViewRemoteBase;
350 ClientView->ViewSize = ConnectMessage->ClientView.ViewSize;
351 }
352
353 /* Return the handle to user mode */
354 *PortHandle = Handle;
355 }
356 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
357 {
358 /* Cleanup and return the exception code */
359 ObCloseHandle(Handle, PreviousMode);
360 ObDereferenceObject(ServerPort);
361 Status = _SEH2_GetExceptionCode();
362 _SEH2_YIELD(goto Cleanup);
363 }
364 _SEH2_END;
365
366 LPCTRACE(LPC_COMPLETE_DEBUG,
367 "Handle: %p. Messages: %p/%p. Ports: %p/%p/%p\n",
368 Handle,
369 Message,
370 ConnectMessage,
371 ServerPort,
372 ClientPort,
373 ConnectionPort);
374
375 /* If there was no port context, use the handle by default */
376 if (!PortContext) ServerPort->PortContext = Handle;
377 ServerPort->ClientThread = ClientThread;
378
379 /* Set this message as the LPC Reply message while holding the lock */
380 KeAcquireGuardedMutex(&LpcpLock);
381 ClientThread->LpcReplyMessage = Message;
382 KeReleaseGuardedMutex(&LpcpLock);
383
384 /* Clear the thread pointer so it doesn't get cleaned later */
385 ClientThread = NULL;
386
387 /* Remove the extra reference we had added */
388 ObDereferenceObject(ServerPort);
389
390 Cleanup:
391 /* If there was a section, dereference it */
392 if (ClientSectionToMap) ObDereferenceObject(ClientSectionToMap);
393
394 /* Check if we got here while still having a client thread */
395 if (ClientThread)
396 {
397 KeAcquireGuardedMutex(&LpcpLock);
398 ClientThread->LpcReplyMessage = Message;
399 LpcpPrepareToWakeClient(ClientThread);
400 KeReleaseGuardedMutex(&LpcpLock);
401 LpcpCompleteWait(&ClientThread->LpcReplySemaphore);
402 ObDereferenceObject(ClientThread);
403 }
404
405 /* Dereference the client port if we have one, and the process */
406 LPCTRACE(LPC_COMPLETE_DEBUG,
407 "Status: %lx. Thread: %p. Process: [%.16s]\n",
408 Status,
409 ClientThread,
410 ClientProcess->ImageFileName);
411 if (ClientPort) ObDereferenceObject(ClientPort);
412 ObDereferenceObject(ClientProcess);
413 return Status;
414 }
415
416 /*
417 * @implemented
418 */
419 NTSTATUS
420 NTAPI
421 NtCompleteConnectPort(IN HANDLE PortHandle)
422 {
423 NTSTATUS Status;
424 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
425 PLPCP_PORT_OBJECT Port;
426 PETHREAD Thread;
427
428 PAGED_CODE();
429 LPCTRACE(LPC_COMPLETE_DEBUG, "Handle: %p\n", PortHandle);
430
431 /* Get the Port Object */
432 Status = ObReferenceObjectByHandle(PortHandle,
433 PORT_ALL_ACCESS,
434 LpcPortObjectType,
435 PreviousMode,
436 (PVOID*)&Port,
437 NULL);
438 if (!NT_SUCCESS(Status)) return Status;
439
440 /* Make sure this is a connection port */
441 if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_COMMUNICATION_PORT)
442 {
443 /* It isn't, fail */
444 ObDereferenceObject(Port);
445 return STATUS_INVALID_PORT_HANDLE;
446 }
447
448 /* Acquire the lock */
449 KeAcquireGuardedMutex(&LpcpLock);
450
451 /* Make sure we have a client thread */
452 if (!Port->ClientThread)
453 {
454 /* We don't, fail */
455 KeReleaseGuardedMutex(&LpcpLock);
456 ObDereferenceObject(Port);
457 return STATUS_INVALID_PARAMETER;
458 }
459
460 /* Get the thread */
461 Thread = Port->ClientThread;
462
463 /* Make sure it has a reply message */
464 if (!LpcpGetMessageFromThread(Thread))
465 {
466 /* It doesn't, quit */
467 KeReleaseGuardedMutex(&LpcpLock);
468 ObDereferenceObject(Port);
469 return STATUS_SUCCESS;
470 }
471
472 /* Clear the client thread and wake it up */
473 Port->ClientThread = NULL;
474 LpcpPrepareToWakeClient(Thread);
475
476 /* Release the lock and wait for an answer */
477 KeReleaseGuardedMutex(&LpcpLock);
478 LpcpCompleteWait(&Thread->LpcReplySemaphore);
479
480 /* Dereference the Thread and Port and return */
481 ObDereferenceObject(Port);
482 ObDereferenceObject(Thread);
483 LPCTRACE(LPC_COMPLETE_DEBUG, "Port: %p. Thread: %p\n", Port, Thread);
484 return Status;
485 }
486
487 /* EOF */