Ros-diffs October 2006

ros-diffs@reactos.org

17 participants
357 discussions

[ion] 24673: - Implement NtRequestWaitReplyPort. This is a simple implementation that doesn't support Callback LPC Messages yet (Since we don't make use of them). SMSS can now send API messages on the Sb Port. - With these APIs we now have a skeleton NTLPC that is fully NT-compatible. Thanks to ea's (Emanuele)'s smss work which he strived to make portable, building with NTLPC = 1 will also build a compatible smss that now works. - CSRSS requires some changes since it was not written to be NTLPC

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:50:31 2006 New Revision: 24673 URL: http://svn.reactos.org/svn/reactos?rev=24673&view=rev Log: - Implement NtRequestWaitReplyPort. This is a simple implementation that doesn't support Callback LPC Messages yet (Since we don't make use of them). SMSS can now send API messages on the Sb Port. - With these APIs we now have a skeleton NTLPC that is fully NT-compatible. Thanks to ea's (Emanuele)'s smss work which he strived to make portable, building with NTLPC = 1 will also build a compatible smss that now works. - CSRSS requires some changes since it was not written to be NTLPC portable. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/send.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/send.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/send.c?… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/send.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/send.c Mon Oct 30 17:50:31 2006 @@ -61,8 +61,251 @@ IN PPORT_MESSAGE LpcRequest, IN OUT PPORT_MESSAGE LpcReply) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PLPCP_PORT_OBJECT Port, QueuePort, ReplyPort; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); + NTSTATUS Status; + PLPCP_MESSAGE Message; + PETHREAD Thread = PsGetCurrentThread(); + BOOLEAN Callback; + PKSEMAPHORE Semaphore; + ULONG MessageType; + PAGED_CODE(); + LPCTRACE(LPC_SEND_DEBUG, + "Handle: %lx. Messages: %p/%p. Type: %lx\n", + PortHandle, + LpcRequest, + LpcReply, + LpcpGetMessageType(LpcRequest)); + + /* Check if the thread is dying */ + if (Thread->LpcExitThreadCalled) return STATUS_THREAD_IS_TERMINATING; + + /* Check if this is an LPC Request */ + if (LpcpGetMessageType(LpcRequest) == LPC_REQUEST) + { + /* Then it's a callback */ + Callback = TRUE; + } + else if (LpcpGetMessageType(LpcRequest)) + { + /* This is a not kernel-mode message */ + return STATUS_INVALID_PARAMETER; + } + else + { + /* This is a kernel-mode message without a callback */ + LpcRequest->u2.s2.Type |= LPC_REQUEST; + Callback = FALSE; + } + + /* Get the message type */ + MessageType = LpcRequest->u2.s2.Type; + + /* Validate the length */ + if ((LpcRequest->u1.s1.DataLength + sizeof(PORT_MESSAGE)) > + LpcRequest->u1.s1.TotalLength) + { + /* Fail */ + return STATUS_INVALID_PARAMETER; + } + + /* Reference the object */ + Status = ObReferenceObjectByHandle(PortHandle, + 0, + LpcPortObjectType, + PreviousMode, + (PVOID*)&Port, + NULL); + if (!NT_SUCCESS(Status)) return Status; + + /* Validate the message length */ + if ((LpcRequest->u1.s1.TotalLength > Port->MaxMessageLength) || + (LpcRequest->u1.s1.TotalLength <= LpcRequest->u1.s1.DataLength)) + { + /* Fail */ + ObDereferenceObject(Port); + return STATUS_PORT_MESSAGE_TOO_LONG; + } + + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Allocate a message */ + Message = ExAllocateFromPagedLookasideList(&LpcpMessagesLookaside); + KeReleaseGuardedMutex(&LpcpLock); + + /* Check if allocation worked */ + if (!Message) + { + /* Fail */ + ObDereferenceObject(Port); + return STATUS_NO_MEMORY; + } + + /* Check if this is a callback */ + if (Callback) + { + /* FIXME: TODO */ + Semaphore = NULL; // we'd use the Thread Semaphore here + ASSERT(FALSE); + } + else + { + /* No callback, just copy the message */ + LpcpMoveMessage(&Message->Request, + LpcRequest, + LpcRequest + 1, + MessageType, + &Thread->Cid); + + /* Acquire the LPC lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Right now clear the port context */ + Message->PortContext = NULL; + + /* Check if this is a not connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT) + { + /* We want the connected port */ + QueuePort = Port->ConnectedPort; + if (!QueuePort) + { + /* We have no connected port, fail */ + LpcpFreeToPortZone(Message, TRUE); + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(Port); + return STATUS_PORT_DISCONNECTED; + } + + /* This will be the rundown port */ + ReplyPort = QueuePort; + + /* Check if this is a communication port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT) + { + /* Copy the port context and use the connection port */ + Message->PortContext = ReplyPort->PortContext; + QueuePort = Port->ConnectionPort; + } + else if ((Port->Flags & LPCP_PORT_TYPE_MASK) != + LPCP_COMMUNICATION_PORT) + { + /* Use the connection port for anything but communication ports */ + QueuePort = Port->ConnectionPort; + } + } + else + { + /* Otherwise, for a connection port, use the same port object */ + QueuePort = ReplyPort = Port; + } + + /* No reply thread */ + Message->RepliedToThread = NULL; + + /* Generate the Message ID and set it */ + Message->Request.MessageId = LpcpNextMessageId++; + if (!LpcpNextMessageId) LpcpNextMessageId = 1; + Message->Request.CallbackId = 0; + + /* Set the message ID for our thread now */ + Thread->LpcReplyMessageId = Message->Request.MessageId; + Thread->LpcReplyMessage = NULL; + + /* Insert the message in our chain */ + InsertTailList(&QueuePort->MsgQueue.ReceiveHead, &Message->Entry); + InsertTailList(&ReplyPort->LpcReplyChainHead, &Thread->LpcReplyChain); + + /* Release the lock and get the semaphore we'll use later */ + KeReleaseGuardedMutex(&LpcpLock); + Semaphore = QueuePort->MsgQueue.Semaphore; + + /* If this is a waitable port, wake it up */ + if (QueuePort->Flags & LPCP_WAITABLE_PORT) + { + /* Wake it */ + KeSetEvent(&QueuePort->WaitEvent, IO_NO_INCREMENT, FALSE); + } + } + + /* Now release the semaphore */ + LpcpCompleteWait(Semaphore); + + /* And let's wait for the reply */ + LpcpReplyWait(&Thread->LpcReplySemaphore, PreviousMode); + + /* Acquire the LPC lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Get the LPC Message and clear our thread's reply data */ + Message = Thread->LpcReplyMessage; + Thread->LpcReplyMessage = NULL; + Thread->LpcReplyMessageId = 0; + + /* Check if we have anything on the reply chain*/ + if (!IsListEmpty(&Thread->LpcReplyChain)) + { + /* Remove this thread and reinitialize the list */ + RemoveEntryList(&Thread->LpcReplyChain); + InitializeListHead(&Thread->LpcReplyChain); + } + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Check if we got a reply */ + if (Status == STATUS_SUCCESS) + { + /* Check if we have a valid message */ + if (Message) + { + LPCTRACE(LPC_SEND_DEBUG, + "Reply Messages: %p/%p\n", + &Message->Request, + (&Message->Request) + 1); + + /* Move the message */ + LpcpMoveMessage(LpcReply, + &Message->Request, + (&Message->Request) + 1, + 0, + NULL); + + /* Check if this is an LPC request with data information */ + if ((LpcpGetMessageType(&Message->Request) == LPC_REQUEST) && + (Message->Request.u2.s2.DataInfoOffset)) + { + /* Save the data information */ + LpcpSaveDataInfoMessage(Port, Message); + } + else + { + /* Otherwise, just free it */ + LpcpFreeToPortZone(Message, FALSE); + } + } + else + { + /* We don't have a reply */ + Status = STATUS_LPC_REPLY_LOST; + } + } + else + { + /* The wait failed, free the message while holding the lock */ + KeAcquireGuardedMutex(&LpcpLock); + LpcpFreeToPortZone(Message, TRUE); + KeReleaseGuardedMutex(&LpcpLock); + } + + /* All done */ + LPCTRACE(LPC_SEND_DEBUG, + "Port: %p. Status: %p\n", + Port, + Status); + ObDereferenceObject(Port); + return Status; } /* EOF */

18 years, 1 month

[ion] 24672: - Implement NtSecureConnectPort so that clients can connect to SMSS. Does not yet support actual secure connections (with a SID) and will fail those requests. Also doesn't support memory-mapped LPC yet.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:46:56 2006 New Revision: 24672 URL: http://svn.reactos.org/svn/reactos?rev=24672&view=rev Log: - Implement NtSecureConnectPort so that clients can connect to SMSS. Does not yet support actual secure connections (with a SID) and will fail those requests. Also doesn't support memory-mapped LPC yet. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/connect… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c Mon Oct 30 17:46:56 2006 @@ -14,6 +14,52 @@ #include <internal/debug.h> /* PRIVATE FUNCTIONS *********************************************************/ + +PVOID +NTAPI +LpcpFreeConMsg(IN OUT PLPCP_MESSAGE *Message, + IN OUT PLPCP_CONNECTION_MESSAGE *ConnectMessage, + IN PETHREAD CurrentThread) +{ + PVOID SectionToMap; + + /* Acquire the LPC lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Check if the reply chain is not empty */ + if (!IsListEmpty(&CurrentThread->LpcReplyChain)) + { + /* Remove this entry and re-initialize it */ + RemoveEntryList(&CurrentThread->LpcReplyChain); + InitializeListHead(&CurrentThread->LpcReplyChain); + } + + /* Check if there's a reply message */ + if (CurrentThread->LpcReplyMessage) + { + /* Get the message */ + *Message = CurrentThread->LpcReplyMessage; + + /* Clear message data */ + CurrentThread->LpcReceivedMessageId = 0; + CurrentThread->LpcReplyMessage = NULL; + + /* Get the connection message and clear the section */ + *ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(*Message + 1); + SectionToMap = (*ConnectMessage)->SectionToMap; + (*ConnectMessage)->SectionToMap = NULL; + } + else + { + /* No message to return */ + *Message = NULL; + SectionToMap = NULL; + } + + /* Release the lock and return the section */ + KeReleaseGuardedMutex(&LpcpLock); + return SectionToMap; +} /* PUBLIC FUNCTIONS **********************************************************/ @@ -32,8 +78,389 @@ IN OUT PVOID ConnectionInformation OPTIONAL, IN OUT PULONG ConnectionInformationLength OPTIONAL) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + ULONG ConnectionInfoLength = 0; + PLPCP_PORT_OBJECT Port, ClientPort; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); + NTSTATUS Status = STATUS_SUCCESS; + HANDLE Handle; + PVOID SectionToMap; + PLPCP_MESSAGE Message; + PLPCP_CONNECTION_MESSAGE ConnectMessage; + PETHREAD Thread = PsGetCurrentThread(); + ULONG PortMessageLength; + PAGED_CODE(); + LPCTRACE(LPC_CONNECT_DEBUG, + "Name: %wZ. Qos: %p. Views: %p/%p\n", + PortName, + Qos, + ClientView, + ServerView); + + /* Validate client view */ + if ((ClientView) && (ClientView->Length != sizeof(PORT_VIEW))) + { + /* Fail */ + return STATUS_INVALID_PARAMETER; + } + + /* Validate server view */ + if ((ServerView) && (ServerView->Length != sizeof(REMOTE_PORT_VIEW))) + { + /* Fail */ + return STATUS_INVALID_PARAMETER; + } + + /* Check if caller sent connection information length */ + if (ConnectionInformationLength) + { + /* Retrieve the input length */ + ConnectionInfoLength = *ConnectionInformationLength; + } + + /* Get the port */ + Status = ObReferenceObjectByName(PortName, + 0, + NULL, + PORT_ALL_ACCESS, + LpcPortObjectType, + PreviousMode, + NULL, + (PVOID *)&Port); + if (!NT_SUCCESS(Status)) return Status; + + /* This has to be a connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CONNECTION_PORT) + { + /* It isn't, so fail */ + ObDereferenceObject(Port); + return STATUS_INVALID_PORT_HANDLE; + } + + /* Check if we have a SID */ + if (ServerSid) + { + /* FIXME: TODO */ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; + } + + /* Create the client port */ + Status = ObCreateObject(PreviousMode, + LpcPortObjectType, + NULL, + PreviousMode, + NULL, + sizeof(LPCP_PORT_OBJECT), + 0, + 0, + (PVOID *)&ClientPort); + if (!NT_SUCCESS(Status)) + { + /* Failed, dereference the server port and return */ + ObDereferenceObject(Port); + return Status; + } + + /* Setup the client port */ + RtlZeroMemory(ClientPort, sizeof(LPCP_PORT_OBJECT)); + ClientPort->Flags = LPCP_CLIENT_PORT; + ClientPort->ConnectionPort = Port; + ClientPort->MaxMessageLength = Port->MaxMessageLength; + ClientPort->SecurityQos = *Qos; + InitializeListHead(&ClientPort->LpcReplyChainHead); + InitializeListHead(&ClientPort->LpcDataInfoChainHead); + + /* Check if we have dynamic security */ + if (Qos->ContextTrackingMode == SECURITY_DYNAMIC_TRACKING) + { + /* Remember that */ + ClientPort->Flags |= LPCP_SECURITY_DYNAMIC; + } + else + { + /* Create our own client security */ + Status = SeCreateClientSecurity(Thread, + Qos, + FALSE, + &ClientPort->StaticSecurity); + if (!NT_SUCCESS(Status)) + { + /* Security failed, dereference and return */ + ObDereferenceObject(ClientPort); + return Status; + } + } + + /* Initialize the port queue */ + Status = LpcpInitializePortQueue(ClientPort); + if (!NT_SUCCESS(Status)) + { + /* Failed */ + ObDereferenceObject(ClientPort); + return Status; + } + + /* Check if we have a client view */ + if (ClientView) + { + /* FIXME: TODO */ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; + } + else + { + /* No section */ + SectionToMap = NULL; + } + + /* Normalize connection information */ + if (ConnectionInfoLength > Port->MaxConnectionInfoLength) + { + /* Use the port's maximum allowed value */ + ConnectionInfoLength = Port->MaxConnectionInfoLength; + } + + /* Allocate a message from the port zone while holding the lock */ + KeAcquireGuardedMutex(&LpcpLock); + Message = ExAllocateFromPagedLookasideList(&LpcpMessagesLookaside); + if (!Message) + { + /* Fail if we couldn't allocate a message */ + KeReleaseGuardedMutex(&LpcpLock); + if (SectionToMap) ObDereferenceObject(SectionToMap); + ObDereferenceObject(ClientPort); + return STATUS_NO_MEMORY; + } + + /* Initialize it */ + InitializeListHead(&Message->Entry); + Message->RepliedToThread = NULL; + Message->Request.u2.ZeroInit = 0; + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Set pointer to the connection message and fill in the CID */ + ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1); + Message->Request.ClientId = Thread->Cid; + + /* Check if we have a client view */ + if (ClientView) + { + /* FIXME: TODO */ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; + } + else + { + /* Set the size to 0 and clear the connect message */ + Message->Request.ClientViewSize = 0; + RtlZeroMemory(ConnectMessage, sizeof(LPCP_CONNECTION_MESSAGE)); + } + + /* Set the section and client port. Port is NULL for now */ + ConnectMessage->ClientPort = NULL; + ConnectMessage->SectionToMap = SectionToMap; + + /* Set the data for the connection request message */ + Message->Request.u1.s1.DataLength = sizeof(LPCP_CONNECTION_MESSAGE) + + ConnectionInfoLength; + Message->Request.u1.s1.TotalLength = sizeof(LPCP_MESSAGE) + + Message->Request.u1.s1.DataLength; + Message->Request.u2.s2.Type = LPC_CONNECTION_REQUEST; + + /* Check if we have connection information */ + if (ConnectionInformation) + { + /* Copy it in */ + RtlMoveMemory(ConnectMessage + 1, + ConnectionInformation, + ConnectionInfoLength); + } + + /* Acquire the port lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Check if someone already deleted the port name */ + if (Port->Flags & LPCP_NAME_DELETED) + { + /* Fail the request */ + KeReleaseGuardedMutex(&LpcpLock); + Status = STATUS_OBJECT_NAME_NOT_FOUND; + goto Cleanup; + } + + /* Associate no thread yet */ + Message->RepliedToThread = NULL; + + /* Generate the Message ID and set it */ + Message->Request.MessageId = LpcpNextMessageId++; + if (!LpcpNextMessageId) LpcpNextMessageId = 1; + Thread->LpcReplyMessageId = Message->Request.MessageId; + + /* Insert the message into the queue and thread chain */ + InsertTailList(&Port->MsgQueue.ReceiveHead, &Message->Entry); + InsertTailList(&Port->LpcReplyChainHead, &Thread->LpcReplyChain); + Thread->LpcReplyMessage = Message; + + /* Now we can finally reference the client port and link it*/ + ObReferenceObject(ClientPort); + ConnectMessage->ClientPort = ClientPort; + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + LPCTRACE(LPC_CONNECT_DEBUG, + "Messages: %p/%p. Ports: %p/%p. Status: %lx\n", + Message, + ConnectMessage, + Port, + ClientPort, + Status); + + /* If this is a waitable port, set the event */ + if (Port->Flags & LPCP_WAITABLE_PORT) KeSetEvent(&Port->WaitEvent, + 1, + FALSE); + + /* Release the queue semaphore */ + LpcpCompleteWait(Port->MsgQueue.Semaphore); + + /* Now wait for a reply */ + LpcpConnectWait(&Thread->LpcReplySemaphore, PreviousMode); + + /* Check if our wait ended in success */ + if (Status != STATUS_SUCCESS) goto Cleanup; + + /* Free the connection message */ + SectionToMap = LpcpFreeConMsg(&Message, &ConnectMessage, Thread); + + /* Check if we got a message back */ + if (Message) + { + /* Check for new return length */ + if ((Message->Request.u1.s1.DataLength - + sizeof(LPCP_CONNECTION_MESSAGE)) < ConnectionInfoLength) + { + /* Set new normalized connection length */ + ConnectionInfoLength = Message->Request.u1.s1.DataLength - + sizeof(LPCP_CONNECTION_MESSAGE); + } + + /* Check if we had connection information */ + if (ConnectionInformation) + { + /* Check if we had a length pointer */ + if (ConnectionInformationLength) + { + /* Return the length */ + *ConnectionInformationLength = ConnectionInfoLength; + } + + /* Return the connection information */ + RtlMoveMemory(ConnectionInformation, + ConnectMessage + 1, + ConnectionInfoLength ); + } + + /* Make sure we had a connected port */ + if (ClientPort->ConnectedPort) + { + /* Get the message length before the port might get killed */ + PortMessageLength = Port->MaxMessageLength; + + /* Insert the client port */ + Status = ObInsertObject(ClientPort, + NULL, + PORT_ALL_ACCESS, + 0, + (PVOID *)NULL, + &Handle); + if (NT_SUCCESS(Status)) + { + /* Return the handle */ + *PortHandle = Handle; + LPCTRACE(LPC_CONNECT_DEBUG, + "Handle: %lx. Length: %lx\n", + Handle, + PortMessageLength); + + /* Check if maximum length was requested */ + if (MaxMessageLength) *MaxMessageLength = PortMessageLength; + + /* Check if we had a client view */ + if (ClientView) + { + /* Copy it back */ + RtlMoveMemory(ClientView, + &ConnectMessage->ClientView, + sizeof(PORT_VIEW)); + } + + /* Check if we had a server view */ + if (ServerView) + { + /* Copy it back */ + RtlMoveMemory(ServerView, + &ConnectMessage->ServerView, + sizeof(REMOTE_PORT_VIEW)); + } + } + } + else + { + /* No connection port, we failed */ + if (SectionToMap) ObDereferenceObject(SectionToMap); + + /* Check if it's because the name got deleted */ + if (Port->Flags & LPCP_NAME_DELETED) + { + /* Set the correct status */ + Status = STATUS_OBJECT_NAME_NOT_FOUND; + } + else + { + /* Otherwise, the caller refused us */ + Status = STATUS_PORT_CONNECTION_REFUSED; + } + + /* Kill the port */ + ObDereferenceObject(ClientPort); + } + + /* Free the message */ + LpcpFreeToPortZone(Message, FALSE); + return Status; + } + + /* No reply message, fail */ + if (SectionToMap) ObDereferenceObject(SectionToMap); + ObDereferenceObject(ClientPort); + return STATUS_PORT_CONNECTION_REFUSED; + +Cleanup: + /* We failed, free the message */ + SectionToMap = LpcpFreeConMsg(&Message, &ConnectMessage, Thread); + + /* Check if the semaphore got signaled */ + if (KeReadStateSemaphore(&Thread->LpcReplySemaphore)) + { + /* Wait on it */ + KeWaitForSingleObject(&Thread->LpcReplySemaphore, + KernelMode, + Executive, + FALSE, + NULL); + } + + /* Check if we had a message and free it */ + if (Message) LpcpFreeToPortZone(Message, FALSE); + + /* Dereference other objects */ + if (SectionToMap) ObDereferenceObject(SectionToMap); + ObDereferenceObject(ClientPort); + + /* Return status */ + return Status; } /*

18 years, 1 month

[ion] 24671: - Implement NtCompleteConnectPort. SMSS can now completely accept new incoming connections.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:45:07 2006 New Revision: 24671 URL: http://svn.reactos.org/svn/reactos?rev=24671&view=rev Log: - Implement NtCompleteConnectPort. SMSS can now completely accept new incoming connections. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/complet… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c Mon Oct 30 17:45:07 2006 @@ -14,6 +14,22 @@ #include <internal/debug.h> /* PRIVATE FUNCTIONS *********************************************************/ + +VOID +NTAPI +LpcpPrepareToWakeClient(IN PETHREAD Thread) +{ + PAGED_CODE(); + + /* Make sure the thread isn't dying and it has a valid chain */ + if (!(Thread->LpcExitThreadCalled) && + !(IsListEmpty(&Thread->LpcReplyChain))) + { + /* Remove it from the list and reinitialize it */ + RemoveEntryList(&Thread->LpcReplyChain); + InitializeListHead(&Thread->LpcReplyChain); + } +} /* PUBLIC FUNCTIONS **********************************************************/ @@ -266,8 +282,67 @@ NTAPI NtCompleteConnectPort(IN HANDLE PortHandle) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + NTSTATUS Status; + PLPCP_PORT_OBJECT Port; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); + PETHREAD Thread; + PAGED_CODE(); + LPCTRACE(LPC_COMPLETE_DEBUG, "Handle: %lx\n", PortHandle); + + /* Get the Port Object */ + Status = ObReferenceObjectByHandle(PortHandle, + PORT_ALL_ACCESS, + LpcPortObjectType, + PreviousMode, + (PVOID*)&Port, + NULL); + if (!NT_SUCCESS(Status)) return Status; + + /* Make sure this is a connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_COMMUNICATION_PORT) + { + /* It isn't, fail */ + ObDereferenceObject(Port); + return STATUS_INVALID_PORT_HANDLE; + } + + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Make sure we have a client thread */ + if (!Port->ClientThread) + { + /* We don't, fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(Port); + return STATUS_INVALID_PARAMETER; + } + + /* Get the thread */ + Thread = Port->ClientThread; + + /* Make sure it has a reply message */ + if (!Thread->LpcReplyMessage) + { + /* It doesn't, fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(Port); + return STATUS_PORT_DISCONNECTED; + } + + /* Clear the client thread and wake it up */ + Port->ClientThread = NULL; + LpcpPrepareToWakeClient(Thread); + + /* Release the lock and wait for an answer */ + KeReleaseGuardedMutex(&LpcpLock); + LpcpCompleteWait(&Thread->LpcReplySemaphore); + + /* Dereference the Thread and Port and return */ + ObDereferenceObject(Port); + ObDereferenceObject(Thread); + LPCTRACE(LPC_COMPLETE_DEBUG, "Port: %p. Thread: %p\n", Port, Thread); + return Status; } /* EOF */

18 years, 1 month

[ion] 24670: - Implement NtAcceptConnectPort. This is a naive implementation that doesn't support memory-mapped LPC yet (since it's not used by SMSS). Such LPC messages will hit an ASSERT for now (when they do, I'll implement the missing functionalitY).

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:44:05 2006 New Revision: 24670 URL: http://svn.reactos.org/svn/reactos?rev=24670&view=rev Log: - Implement NtAcceptConnectPort. This is a naive implementation that doesn't support memory-mapped LPC yet (since it's not used by SMSS). Such LPC messages will hit an ASSERT for now (when they do, I'll implement the missing functionalitY). Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/complet… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c Mon Oct 30 17:44:05 2006 @@ -29,8 +29,234 @@ IN PPORT_VIEW ClientView, IN PREMOTE_PORT_VIEW ServerView) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PLPCP_PORT_OBJECT ConnectionPort, ServerPort, ClientPort; + PVOID ClientSectionToMap = NULL; + HANDLE Handle; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); + NTSTATUS Status; + ULONG ConnectionInfoLength; + PLPCP_MESSAGE Msg; + PLPCP_CONNECTION_MESSAGE ConnectMsg; + PEPROCESS ClientProcess; + PETHREAD ClientThread; + PAGED_CODE(); + LPCTRACE(LPC_COMPLETE_DEBUG, + "Context: %p. Message: %p. Accept: %lx. Views: %p/%p\n", + PortContext, + ReplyMessage, + AcceptConnection, + ClientView, + ServerView); + + /* Validate the size of the server view */ + if ((ServerView) && (ServerView->Length != sizeof(PORT_VIEW))) + { + /* Invalid size */ + return STATUS_INVALID_PARAMETER; + } + + /* Validate the size of the client view */ + if ((ClientView) && (ClientView->Length != sizeof(REMOTE_PORT_VIEW))) + { + /* Invalid size */ + return STATUS_INVALID_PARAMETER; + } + + /* Get the client process and thread */ + Status = PsLookupProcessThreadByCid(&ReplyMessage->ClientId, + &ClientProcess, + &ClientThread); + if (!NT_SUCCESS(Status)) return Status; + + /* Acquire the LPC Lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Make sure that the client wants a reply, and this is the right one */ + if (!(ClientThread->LpcReplyMessage) || + !(ReplyMessage->MessageId) || + (ClientThread->LpcReplyMessageId != ReplyMessage->MessageId)) + { + /* Not the reply asked for, or no reply wanted, fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(ClientProcess); + ObDereferenceObject(ClientThread); + return STATUS_REPLY_MESSAGE_MISMATCH; + } + + /* Now get the message and connection message */ + Msg = ClientThread->LpcReplyMessage; + ConnectMsg = (PLPCP_CONNECTION_MESSAGE)(Msg + 1); + + /* Get the client and connection port as well */ + ClientPort = ConnectMsg->ClientPort; + ConnectionPort = ClientPort->ConnectionPort; + + /* Make sure that the reply is being sent to the proper server process */ + if (ConnectionPort->ServerProcess != PsGetCurrentProcess()) + { + /* It's not, so fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(ClientProcess); + ObDereferenceObject(ClientThread); + return STATUS_REPLY_MESSAGE_MISMATCH; + } + + /* At this point, don't let other accept attempts happen */ + ClientThread->LpcReplyMessage = NULL; + ClientThread->LpcReplyMessageId = 0; + + /* Clear the client port for now as well, then release the lock */ + ConnectMsg->ClientPort = NULL; + KeReleaseGuardedMutex(&LpcpLock); + + /* Get the connection information length */ + ConnectionInfoLength = ReplyMessage->u1.s1.DataLength; + if (ConnectionInfoLength > ConnectionPort->MaxConnectionInfoLength) + { + /* Normalize it since it's too large */ + ConnectionInfoLength = ConnectionPort->MaxConnectionInfoLength; + } + + /* Set the sizes of our reply message */ + Msg->Request.u1.s1.DataLength = sizeof(LPCP_CONNECTION_MESSAGE) + + ConnectionInfoLength; + Msg->Request.u1.s1.TotalLength = sizeof(LPCP_MESSAGE) + + Msg->Request.u1.s1.DataLength; + + /* Setup the reply message */ + Msg->Request.u2.s2.Type = LPC_REPLY; + Msg->Request.u2.s2.DataInfoOffset = 0; + Msg->Request.ClientId = ReplyMessage->ClientId; + Msg->Request.MessageId = ReplyMessage->MessageId; + Msg->Request.ClientViewSize = 0; + RtlMoveMemory(ConnectMsg + 1, ReplyMessage + 1, ConnectionInfoLength); + + /* At this point, if the caller refused the connection, go to cleanup */ + if (!AcceptConnection) goto Cleanup; + + /* Otherwise, create the actual port */ + Status = ObCreateObject(PreviousMode, + LpcPortObjectType, + NULL, + PreviousMode, + NULL, + sizeof(LPCP_PORT_OBJECT), + 0, + 0, + (PVOID*)&ServerPort); + if (!NT_SUCCESS(Status)) goto Cleanup; + + /* Set it up */ + RtlZeroMemory(ServerPort, sizeof(LPCP_PORT_OBJECT)); + ServerPort->PortContext = PortContext; + ServerPort->Flags = LPCP_COMMUNICATION_PORT; + ServerPort->MaxMessageLength = ConnectionPort->MaxMessageLength; + InitializeListHead(&ServerPort->LpcReplyChainHead); + InitializeListHead(&ServerPort->LpcDataInfoChainHead); + + /* Reference the connection port until we're fully setup */ + ObReferenceObject(ConnectionPort); + + /* Link the ports together */ + ServerPort->ConnectionPort = ConnectionPort; + ServerPort->ConnectedPort = ClientPort; + ClientPort->ConnectedPort = ServerPort; + + /* Also set the creator CID */ + ServerPort->Creator = PsGetCurrentThread()->Cid; + ClientPort->Creator = Msg->Request.ClientId; + + /* Get the section associated and then clear it, while inside the lock */ + KeAcquireGuardedMutex(&LpcpLock); + ClientSectionToMap = ConnectMsg->SectionToMap; + ConnectMsg->SectionToMap = NULL; + KeReleaseGuardedMutex(&LpcpLock); + + /* Now check if there's a client section */ + if (ClientSectionToMap) + { + /* FIXME: TODO */ + ASSERT(FALSE); + } + + /* Check if there's a server section */ + if (ServerView) + { + /* FIXME: TODO */ + ASSERT(FALSE); + } + + /* Reference the server port until it's fully inserted */ + ObReferenceObject(ServerPort); + + /* Insert the server port in the namespace */ + Status = ObInsertObject(ServerPort, + NULL, + PORT_ALL_ACCESS, + 0, + NULL, + &Handle); + if (!NT_SUCCESS(Status)) + { + /* We failed, remove the extra reference and cleanup */ + ObDereferenceObject(ServerPort); + goto Cleanup; + } + + /* Check if the caller gave a client view */ + if (ClientView) + { + /* Fill it out */ + ClientView->ViewBase = ConnectMsg->ClientView.ViewRemoteBase; + ClientView->ViewSize = ConnectMsg->ClientView.ViewSize; + } + + /* Return the handle to user mode */ + *PortHandle = Handle; + LPCTRACE(LPC_COMPLETE_DEBUG, + "Handle: %lx. Messages: %p/%p. Ports: %p/%p/%p\n", + Handle, + Msg, + ConnectMsg, + ServerPort, + ClientPort, + ConnectionPort); + + /* If there was no port context, use the handle by default */ + if (!PortContext) ServerPort->PortContext = Handle; + ServerPort->ClientThread = ClientThread; + + /* Set this message as the LPC Reply message while holding the lock */ + KeAcquireGuardedMutex(&LpcpLock); + ClientThread->LpcReplyMessage = Msg; + KeReleaseGuardedMutex(&LpcpLock); + + /* Clear the thread pointer so it doesn't get cleaned later */ + ClientThread = NULL; + + /* Remove the extra reference we had added */ + ObDereferenceObject(ServerPort); + +Cleanup: + /* If there was a section, dereference it */ + if (ClientSectionToMap) ObDereferenceObject(ClientSectionToMap); + + /* Check if we got here while still having a client thread */ + if (ClientThread) + { + /* FIXME: Complex cleanup code */ + ASSERT(FALSE); + } + + /* Dereference the client port if we have one, and the process */ + LPCTRACE(LPC_COMPLETE_DEBUG, + "Status: %lx. Thread: %p. Process: [%.16s]\n", + Status, + ClientThread, + ClientProcess->ImageFileName); + if (ClientPort) ObDereferenceObject(ClientPort); + ObDereferenceObject(ClientProcess); + return Status; } /*

18 years, 1 month

[ion] 24669: - Implement NtReplyWaitReceivePortEx (And LpcpSave/FreeDataInfoMessage and LpcpMoveMessage). SMSS can now respond to connection attempts.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:42:07 2006 New Revision: 24669 URL: http://svn.reactos.org/svn/reactos?rev=24669&view=rev Log: - Implement NtReplyWaitReceivePortEx (And LpcpSave/FreeDataInfoMessage and LpcpMoveMessage). SMSS can now respond to connection attempts. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c Mon Oct 30 17:42:07 2006 @@ -15,6 +15,115 @@ /* PRIVATE FUNCTIONS *********************************************************/ +VOID +NTAPI +LpcpFreeDataInfoMessage(IN PLPCP_PORT_OBJECT Port, + IN ULONG MessageId, + IN ULONG CallbackId) +{ + PLPCP_MESSAGE Message; + PLIST_ENTRY ListHead, NextEntry; + + /* Check if the port we want is the connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) > LPCP_UNCONNECTED_PORT) + { + /* Use it */ + Port = Port->ConnectionPort; + } + + /* Loop the list */ + ListHead = &Port->LpcDataInfoChainHead; + NextEntry = ListHead->Flink; + while (ListHead != NextEntry) + { + /* Get the message */ + Message = CONTAINING_RECORD(NextEntry, LPCP_MESSAGE, Entry); + + /* Make sure it matches */ + if ((Message->Request.MessageId == MessageId) && + (Message->Request.CallbackId == CallbackId)) + { + /* Unlink and free it */ + RemoveEntryList(&Message->Entry); + InitializeListHead(&Message->Entry); + LpcpFreeToPortZone(Message, TRUE); + break; + } + + /* Go to the next entry */ + NextEntry = NextEntry->Flink; + } +} + +VOID +NTAPI +LpcpSaveDataInfoMessage(IN PLPCP_PORT_OBJECT Port, + IN PLPCP_MESSAGE Message) +{ + PAGED_CODE(); + + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Check if the port we want is the connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) > LPCP_UNCONNECTED_PORT) + { + /* Use it */ + Port = Port->ConnectionPort; + } + + /* Link the message */ + InsertTailList(&Port->LpcDataInfoChainHead, &Message->Entry); + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); +} + +VOID +NTAPI +LpcpMoveMessage(IN PPORT_MESSAGE Destination, + IN PPORT_MESSAGE Origin, + IN PVOID Data, + IN ULONG MessageType, + IN PCLIENT_ID ClientId) +{ + /* Set the Message size */ + LPCTRACE((LPC_REPLY_DEBUG | LPC_SEND_DEBUG), + "Destination/Origin: %p/%p. Data: %p. Length: %lx\n", + Destination, + Origin, + Data, + Origin->u1.Length); + Destination->u1.Length = Origin->u1.Length; + + /* Set the Message Type */ + Destination->u2.s2.Type = !MessageType ? + Origin->u2.s2.Type : MessageType & 0xFFFF; + + /* Check if we have a Client ID */ + if (ClientId) + { + /* Set the Client ID */ + Destination->ClientId.UniqueProcess = ClientId->UniqueProcess; + Destination->ClientId.UniqueThread = ClientId->UniqueThread; + } + else + { + /* Otherwise, copy it */ + Destination->ClientId.UniqueProcess = Origin->ClientId.UniqueProcess; + Destination->ClientId.UniqueThread = Origin->ClientId.UniqueThread; + } + + /* Copy the MessageId and ClientViewSize */ + Destination->MessageId = Origin->MessageId; + Destination->ClientViewSize = Origin->ClientViewSize; + + /* Copy the Message Data */ + RtlMoveMemory(Destination + 1, + Data, + ((Destination->u1.Length & 0xFFFF) + 3) &~3); +} + /* PUBLIC FUNCTIONS **********************************************************/ /* @@ -30,7 +139,7 @@ } /* - * @unimplemented + * @implemented */ NTSTATUS NTAPI @@ -40,8 +149,287 @@ OUT PPORT_MESSAGE ReceiveMessage, IN PLARGE_INTEGER Timeout OPTIONAL) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PLPCP_PORT_OBJECT Port, ReceivePort; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(), WaitMode = PreviousMode; + NTSTATUS Status; + PLPCP_MESSAGE Message; + PETHREAD Thread = PsGetCurrentThread(), WakeupThread; + PLPCP_CONNECTION_MESSAGE ConnectMessage; + ULONG ConnectionInfoLength; + PAGED_CODE(); + LPCTRACE(LPC_REPLY_DEBUG, + "Handle: %lx. Messages: %p/%p. Context: %p\n", + PortHandle, + ReplyMessage, + ReceiveMessage, + PortContext); + + /* If this is a system thread, then let it page out its stack */ + if (Thread->SystemThread) WaitMode = UserMode; + + /* Check if caller has a reply message */ + if (ReplyMessage) + { + /* Validate its length */ + if ((ReplyMessage->u1.s1.DataLength + sizeof(PORT_MESSAGE)) > + ReplyMessage->u1.s1.TotalLength) + { + /* Fail */ + return STATUS_INVALID_PARAMETER; + } + + /* Make sure it has a valid ID */ + if (!ReplyMessage->MessageId) return STATUS_INVALID_PARAMETER; + } + + /* Get the Port object */ + Status = ObReferenceObjectByHandle(PortHandle, + 0, + LpcPortObjectType, + PreviousMode, + (PVOID*)&Port, + NULL); + if (!NT_SUCCESS(Status)) return Status; + + /* Check if the caller has a reply message */ + if (ReplyMessage) + { + /* Validate its length in respect to the port object */ + if ((ReplyMessage->u1.s1.TotalLength > Port->MaxMessageLength) || + (ReplyMessage->u1.s1.TotalLength <= ReplyMessage->u1.s1.DataLength)) + { + /* Too large, fail */ + ObDereferenceObject(Port); + return STATUS_PORT_MESSAGE_TOO_LONG; + } + } + + /* Check if this is anything but a client port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) != LPCP_CLIENT_PORT) + { + /* Use the connection port */ + ReceivePort = Port->ConnectionPort; + } + else + { + /* Otherwise, use the port itself */ + ReceivePort = Port; + } + + /* Check if the caller gave a reply message */ + if (ReplyMessage) + { + /* Get the ETHREAD corresponding to it */ + Status = PsLookupProcessThreadByCid(&ReplyMessage->ClientId, + NULL, + &WakeupThread); + if (!NT_SUCCESS(Status)) + { + /* No thread found, fail */ + ObDereferenceObject(Port); + return Status; + } + + /* Acquire the LPC Lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Allocate a new message */ + Message = ExAllocateFromPagedLookasideList(&LpcpMessagesLookaside); + if (!Message) + { + /* Out of memory, fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(WakeupThread); + ObDereferenceObject(Port); + return STATUS_NO_MEMORY; + } + + /* Initialize the header */ + InitializeListHead(&Message->Entry); + Message->RepliedToThread = NULL; + Message->Request.u2.ZeroInit = 0; + + /* Make sure this is the reply the thread is waiting for */ + if (WakeupThread->LpcReplyMessageId != ReplyMessage->MessageId) + { + /* It isn't, fail */ + LpcpFreeToPortZone(Message, TRUE); + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(WakeupThread); + ObDereferenceObject(Port); + return STATUS_REPLY_MESSAGE_MISMATCH; + } + + /* Copy the message */ + LpcpMoveMessage(&Message->Request, + ReplyMessage, + ReplyMessage + 1, + LPC_REPLY, + NULL); + + /* Free any data information */ + LpcpFreeDataInfoMessage(Port, + ReplyMessage->MessageId, + ReplyMessage->CallbackId); + + /* Reference the thread while we use it */ + ObReferenceObject(WakeupThread); + Message->RepliedToThread = WakeupThread; + + /* Set this as the reply message */ + WakeupThread->LpcReplyMessageId = 0; + WakeupThread->LpcReplyMessage = (PVOID)Message; + + /* Check if we have messages on the reply chain */ + if (!(WakeupThread->LpcExitThreadCalled) && + !(IsListEmpty(&WakeupThread->LpcReplyChain))) + { + /* Remove us from it and reinitiailize it */ + RemoveEntryList(&WakeupThread->LpcReplyChain); + InitializeListHead(&WakeupThread->LpcReplyChain); + } + + /* Check if this is the message the thread had received */ + if ((Thread->LpcReceivedMsgIdValid) && + (Thread->LpcReceivedMessageId == ReplyMessage->MessageId)) + { + /* Clear this data */ + Thread->LpcReceivedMessageId = 0; + Thread->LpcReceivedMsgIdValid = FALSE; + } + + /* Release the lock and release the LPC semaphore to wake up waiters */ + KeReleaseGuardedMutex(&LpcpLock); + LpcpCompleteWait(&WakeupThread->LpcReplySemaphore); + + /* Now we can let go of the thread */ + ObDereferenceObject(WakeupThread); + } + + /* Now wait for someone to reply to us */ + LpcpReceiveWait(ReceivePort->MsgQueue.Semaphore, WaitMode); + if (Status != STATUS_SUCCESS) goto Cleanup; + + /* Wait done, get the LPC lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Check if we've received nothing */ + if (IsListEmpty(&ReceivePort->MsgQueue.ReceiveHead)) + { + /* Check if this was a waitable port and wake it */ + if (ReceivePort->Flags & LPCP_WAITABLE_PORT) + { + /* Reset its event */ + KeResetEvent(&ReceivePort->WaitEvent); + } + + /* Release the lock and fail */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(Port); + return STATUS_UNSUCCESSFUL; + } + + /* Get the message on the queue */ + Message = CONTAINING_RECORD(RemoveHeadList(&ReceivePort-> + MsgQueue.ReceiveHead), + LPCP_MESSAGE, + Entry); + + /* Check if the queue is empty now */ + if (IsListEmpty(&ReceivePort->MsgQueue.ReceiveHead)) + { + /* Check if this was a waitable port */ + if (ReceivePort->Flags & LPCP_WAITABLE_PORT) + { + /* Reset its event */ + KeResetEvent(&ReceivePort->WaitEvent); + } + } + + /* Re-initialize the message's list entry */ + InitializeListHead(&Message->Entry); + + /* Set this as the received message */ + Thread->LpcReceivedMessageId = Message->Request.MessageId; + Thread->LpcReceivedMsgIdValid = TRUE; + + /* Done touching global data, release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Check if this was a connection request */ + if (LpcpGetMessageType(&Message->Request) == LPC_CONNECTION_REQUEST) + { + /* Get the connection message */ + ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1); + LPCTRACE(LPC_REPLY_DEBUG, + "Request Messages: %p/%p\n", + Message, + ConnectMessage); + + /* Get its length */ + ConnectionInfoLength = Message->Request.u1.s1.DataLength - + sizeof(LPCP_CONNECTION_MESSAGE); + + /* Return it as the receive message */ + *ReceiveMessage = Message->Request; + + /* Clear our stack variable so the message doesn't get freed */ + Message = NULL; + + /* Setup the receive message */ + ReceiveMessage->u1.s1.TotalLength = sizeof(LPCP_MESSAGE) + + ConnectionInfoLength; + ReceiveMessage->u1.s1.DataLength = ConnectionInfoLength; + RtlMoveMemory(ReceiveMessage + 1, + ConnectMessage + 1, + ConnectionInfoLength); + + /* Clear the port context if the caller requested one */ + if (PortContext) *PortContext = NULL; + } + else if (Message->Request.u2.s2.Type != LPC_REPLY) + { + /* Otherwise, this is a new message or event */ + LPCTRACE(LPC_REPLY_DEBUG, + "Non-Reply Messages: %p/%p\n", + &Message->Request, + (&Message->Request) + 1); + + /* Copy it */ + LpcpMoveMessage(ReceiveMessage, + &Message->Request, + (&Message->Request) + 1, + 0, + NULL); + + /* Return its context */ + if (PortContext) *PortContext = Message->PortContext; + + /* And check if it has data information */ + if (Message->Request.u2.s2.DataInfoOffset) + { + /* It does, save it, and don't free the message below */ + LpcpSaveDataInfoMessage(Port, Message); + Message = NULL; + } + } + else + { + /* This is a reply message, should never happen! */ + ASSERT(FALSE); + } + + /* If we have a message pointer here, free it */ + if (Message) LpcpFreeToPortZone(Message, FALSE); + +Cleanup: + /* All done, dereference the port and return the status */ + LPCTRACE(LPC_REPLY_DEBUG, + "Port: %p. Status: %p\n", + Port, + Status); + ObDereferenceObject(Port); + return Status; } /*

18 years, 1 month

[ion] 24668: - Implement NtListenPort as a wrapper around NtReplyWaitReceivePort that only listens for connection requests. SMSS can now do this.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:32:18 2006 New Revision: 24668 URL: http://svn.reactos.org/svn/reactos?rev=24668&view=rev Log: - Implement NtListenPort as a wrapper around NtReplyWaitReceivePort that only listens for connection requests. SMSS can now do this. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/listen.… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c Mon Oct 30 17:32:18 2006 @@ -23,8 +23,30 @@ NtListenPort(IN HANDLE PortHandle, OUT PPORT_MESSAGE ConnectMessage) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + NTSTATUS Status; + PAGED_CODE(); + LPCTRACE(LPC_LISTEN_DEBUG, "Handle: %lx\n", PortHandle); + + /* Wait forever for a connection request. */ + for (;;) + { + /* Do the wait */ + Status = NtReplyWaitReceivePort(PortHandle, + NULL, + NULL, + ConnectMessage); + + /* Accept only LPC_CONNECTION_REQUEST requests. */ + if ((Status != STATUS_SUCCESS) || + (LpcpGetMessageType(ConnectMessage) == LPC_CONNECTION_REQUEST)) + { + /* Break out */ + break; + } + } + + /* Return status */ + return Status; } Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h?r… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h Mon Oct 30 17:32:18 2006 @@ -51,7 +51,7 @@ // Gets the message type, removing the kernel-mode flag // #define LpcpGetMessageType(x) \ - ((x)->u2.s2.MessageType &~ LPCP_KERNEL_MESSAGE) + ((x)->u2.s2.Type &~ LPCP_KERNEL_MESSAGE) // // Waits on an LPC semaphore for a receive operation

18 years, 1 month

[ion] 24667: - Implement LpcpCreatePort (And LpcpInitializePortQueue). SMSS can now create the Sb API Port.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:30:20 2006 New Revision: 24667 URL: http://svn.reactos.org/svn/reactos?rev=24667&view=rev Log: - Implement LpcpCreatePort (And LpcpInitializePortQueue). SMSS can now create the Sb API Port. Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/create.c Modified: trunk/reactos/ntoskrnl/lpc/ntlpc/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/create.… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/create.c (original) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/create.c Mon Oct 30 17:30:20 2006 @@ -17,6 +17,28 @@ NTSTATUS NTAPI +LpcpInitializePortQueue(IN PLPCP_PORT_OBJECT Port) +{ + PLPCP_NONPAGED_PORT_QUEUE MessageQueue; + + /* Allocate the queue */ + MessageQueue = ExAllocatePoolWithTag(NonPagedPool, + sizeof(LPCP_NONPAGED_PORT_QUEUE), + TAG('P', 'o', 'r', 't')); + if (!MessageQueue) return STATUS_INSUFFICIENT_RESOURCES; + + /* Set it up */ + KeInitializeSemaphore(&MessageQueue->Semaphore, 0, MAXLONG); + MessageQueue->BackPointer = Port; + + /* And link it with the Paged Pool part */ + Port->MsgQueue.Semaphore = &MessageQueue->Semaphore; + InitializeListHead(&Port->MsgQueue.ReceiveHead); + return STATUS_SUCCESS; +} + +NTSTATUS +NTAPI LpcpCreatePort(OUT PHANDLE PortHandle, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG MaxConnectionInfoLength, @@ -24,8 +46,104 @@ IN ULONG MaxPoolUsage, IN BOOLEAN Waitable) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); + NTSTATUS Status; + PLPCP_PORT_OBJECT Port; + LPCTRACE(LPC_CREATE_DEBUG, "Name: %wZ\n", ObjectAttributes->ObjectName); + + /* Create the Object */ + Status = ObCreateObject(PreviousMode, + LpcPortObjectType, + ObjectAttributes, + PreviousMode, + NULL, + sizeof(LPCP_PORT_OBJECT), + 0, + 0, + (PVOID*)&Port); + if (!NT_SUCCESS(Status)) return Status; + + /* Set up the Object */ + RtlZeroMemory(Port, sizeof(LPCP_PORT_OBJECT)); + Port->ConnectionPort = Port; + Port->Creator = PsGetCurrentThread()->Cid; + InitializeListHead(&Port->LpcDataInfoChainHead); + InitializeListHead(&Port->LpcReplyChainHead); + + /* Check if we don't have a name */ + if (!ObjectAttributes->ObjectName->Buffer) + { + /* Set up for an unconnected port */ + Port->Flags = LPCP_UNCONNECTED_PORT; + Port->ConnectedPort = Port; + Port->ServerProcess = NULL; + } + else + { + /* Set up for a named connection port */ + Port->Flags = LPCP_CONNECTION_PORT; + Port->ServerProcess = PsGetCurrentProcess(); + + /* Don't let the process die on us */ + ObReferenceObject(Port->ServerProcess); + } + + /* Check if this is a waitable port */ + if (Waitable) Port->Flags |= LPCP_WAITABLE_PORT; + + /* Setup the port queue */ + Status = LpcpInitializePortQueue(Port); + if (!NT_SUCCESS(Status)) + { + /* Fail */ + ObDereferenceObject(Port); + return Status; + } + + /* Check if this is a waitable port */ + if (Port->Flags & LPCP_WAITABLE_PORT) + { + /* Setup the wait event */ + KeInitializeEvent(&Port->WaitEvent, NotificationEvent, FALSE); + } + + /* Set the maximum message size allowed */ + Port->MaxMessageLength = LpcpMaxMessageSize - + FIELD_OFFSET(LPCP_MESSAGE, Request); + + /* Now subtract the actual message structures and get the data size */ + Port->MaxConnectionInfoLength = Port->MaxMessageLength - + sizeof(PORT_MESSAGE) - + sizeof(LPCP_CONNECTION_MESSAGE); + + /* Validate the sizes */ + if (Port->MaxConnectionInfoLength < MaxConnectionInfoLength) + { + /* Not enough space for your request */ + ObDereferenceObject(Port); + return STATUS_INVALID_PARAMETER_3; + } + else if (Port->MaxMessageLength < MaxMessageLength) + { + /* Not enough space for your request */ + ObDereferenceObject(Port); + return STATUS_INVALID_PARAMETER_4; + } + + /* Now set the custom setting */ + Port->MaxMessageLength = MaxMessageLength; + + /* Insert it now */ + Status = ObInsertObject((PVOID)Port, + NULL, + PORT_ALL_ACCESS, + 0, + NULL, + PortHandle); + + /* Return success or the error */ + LPCTRACE(LPC_CREATE_DEBUG, "Port: %p. Handle: %lx\n", Port, *PortHandle); + return Status; } /* PUBLIC FUNCTIONS **********************************************************/

18 years, 1 month

[ion] 24666: - Add lpc\ntlpc directory when NTLPC = 1. - Add function stubs in appropriate files. - Implement NtConnectPort (stub to NtSecureConnectPort). Implement NtReplyWaitReceivePort (stub to NtReplyWaitReceivePortEx). Everything else is unimplemented. - Implement LpcpInitSystem and object callbacks LpcpDeletePort and LpcpClosePort. - Add internal lpc.h header.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:28:50 2006 New Revision: 24666 URL: http://svn.reactos.org/svn/reactos?rev=24666&view=rev Log: - Add lpc\ntlpc directory when NTLPC = 1. - Add function stubs in appropriate files. - Implement NtConnectPort (stub to NtSecureConnectPort). Implement NtReplyWaitReceivePort (stub to NtReplyWaitReceivePortEx). Everything else is unimplemented. - Implement LpcpInitSystem and object callbacks LpcpDeletePort and LpcpClosePort. - Add internal lpc.h header. Added: trunk/reactos/ntoskrnl/lpc/ntlpc/ trunk/reactos/ntoskrnl/lpc/ntlpc/close.c trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c trunk/reactos/ntoskrnl/lpc/ntlpc/create.c trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h trunk/reactos/ntoskrnl/lpc/ntlpc/port.c trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c trunk/reactos/ntoskrnl/lpc/ntlpc/send.c Added: trunk/reactos/ntoskrnl/lpc/ntlpc/close.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/close.c… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/close.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/close.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,395 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/close.c + * PURPOSE: Local Procedure Call: Rundown, Cleanup, Deletion + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PRIVATE FUNCTIONS *********************************************************/ + +VOID +NTAPI +LpcExitThread(IN PETHREAD Thread) +{ + PLPCP_MESSAGE Message; + + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Make sure that the Reply Chain is empty */ + if (!IsListEmpty(&Thread->LpcReplyChain)) + { + /* It's not, remove the entry */ + RemoveEntryList(&Thread->LpcReplyChain); + } + + /* Set the thread in exit mode */ + Thread->LpcExitThreadCalled = TRUE; + Thread->LpcReplyMessageId = 0; + + /* Check if there's a reply message */ + Message = Thread->LpcReplyMessage; + if (Message) + { + /* FIXME: TODO */ + ASSERT(FALSE); + } + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); +} + +VOID +NTAPI +LpcpFreeToPortZone(IN PLPCP_MESSAGE Message, + IN ULONG Flags) +{ + PLPCP_CONNECTION_MESSAGE ConnectMessage; + PLPCP_PORT_OBJECT ClientPort = NULL; + PETHREAD Thread = NULL; + BOOLEAN LockHeld = Flags & 1; + PAGED_CODE(); + LPCTRACE(LPC_CLOSE_DEBUG, "Message: %p. Flags: %lx\n", Message, Flags); + + /* Acquire the lock if not already */ + if (!LockHeld) KeAcquireGuardedMutex(&LpcpLock); + + /* Check if the queue list is empty */ + if (!IsListEmpty(&Message->Entry)) + { + /* Remove and re-initialize */ + RemoveEntryList(&Message->Entry); + InitializeListHead(&Message->Entry); + } + + /* Check if we've already replied */ + if (Message->RepliedToThread) + { + /* Set thread to dereference and clean up */ + Thread = Message->RepliedToThread; + Message->RepliedToThread = NULL; + } + + /* Check if this is a connection request */ + if (Message->Request.u2.s2.Type == LPC_CONNECTION_REQUEST) + { + /* Get the connection message */ + ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1); + + /* Clear the client port */ + ClientPort = ConnectMessage->ClientPort; + if (ClientPort) ConnectMessage->ClientPort = NULL; + } + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Check if we had anything to dereference */ + if (Thread) ObDereferenceObject(Thread); + if (ClientPort) ObDereferenceObject(ClientPort); + + /* Free the entry */ + ExFreeToPagedLookasideList(&LpcpMessagesLookaside, Message); + + /* Reacquire the lock if needed */ + if ((LockHeld) && !(Flags & 2)) KeAcquireGuardedMutex(&LpcpLock); +} + +VOID +NTAPI +LpcpDestroyPortQueue(IN PLPCP_PORT_OBJECT Port, + IN BOOLEAN Destroy) +{ + PLIST_ENTRY ListHead, NextEntry; + PETHREAD Thread; + PLPCP_MESSAGE Message; + PLPCP_CONNECTION_MESSAGE ConnectMessage; + LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p. Flags: %lx\n", Port, Port->Flags); + + /* Hold the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Disconnect the port to which this port is connected */ + if (Port->ConnectedPort) Port->ConnectedPort->ConnectedPort = NULL; + + /* Check if this is a connection port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CONNECTION_PORT) + { + /* Delete the name */ + Port->Flags |= LPCP_NAME_DELETED; + } + + /* Walk all the threads waiting and signal them */ + ListHead = &Port->LpcReplyChainHead; + NextEntry = ListHead->Flink; + while (NextEntry != ListHead) + { + /* Get the Thread */ + Thread = CONTAINING_RECORD(NextEntry, ETHREAD, LpcReplyChain); + + /* Make sure we're not in exit */ + if (Thread->LpcExitThreadCalled) break; + + /* Move to the next entry */ + NextEntry = NextEntry->Flink; + + /* Remove and reinitialize the List */ + RemoveEntryList(&Thread->LpcReplyChain); + InitializeListHead(&Thread->LpcReplyChain); + + /* Check if someone is waiting */ + if (!KeReadStateSemaphore(&Thread->LpcReplySemaphore)) + { + /* Get the message and check if it's a connection request */ + Message = Thread->LpcReplyMessage; + if (Message->Request.u2.s2.Type == LPC_CONNECTION_REQUEST) + { + /* Get the connection message */ + ConnectMessage = (PLPCP_CONNECTION_MESSAGE)(Message + 1); + + /* Check if it had a section */ + if (ConnectMessage->SectionToMap) + { + /* Dereference it */ + ObDereferenceObject(ConnectMessage->SectionToMap); + } + } + + /* Clear the reply message */ + Thread->LpcReplyMessage = NULL; + + /* And remove the message from the port zone */ + LpcpFreeToPortZone(Message, TRUE); + } + + /* Release the semaphore and reset message id count */ + Thread->LpcReplyMessageId = 0; + LpcpCompleteWait(&Thread->LpcReplySemaphore); + } + + /* Reinitialize the list head */ + InitializeListHead(&Port->LpcReplyChainHead); + + /* Loop queued messages */ + ListHead = &Port->MsgQueue.ReceiveHead; + NextEntry = ListHead->Flink; + while (ListHead != NextEntry) + { + /* Get the message */ + Message = CONTAINING_RECORD(NextEntry, LPCP_MESSAGE, Entry); + NextEntry = NextEntry->Flink; + + /* Free and reinitialize it's list head */ + InitializeListHead(&Message->Entry); + + /* Remove it from the port zone */ + LpcpFreeToPortZone(Message, TRUE); + } + + /* Reinitialize the message queue list head */ + InitializeListHead(&Port->MsgQueue.ReceiveHead); + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Check if we have to free the port entirely */ + if (Destroy) + { + /* Check if the semaphore exists */ + if (Port->MsgQueue.Semaphore) + { + /* Use the semaphore to find the port queue and free it */ + ExFreePool(CONTAINING_RECORD(Port->MsgQueue.Semaphore, + LPCP_NONPAGED_PORT_QUEUE, + Semaphore)); + } + } +} + +VOID +NTAPI +LpcpClosePort(IN PEPROCESS Process OPTIONAL, + IN PVOID Object, + IN ACCESS_MASK GrantedAccess, + IN ULONG ProcessHandleCount, + IN ULONG SystemHandleCount) +{ + PLPCP_PORT_OBJECT Port = (PLPCP_PORT_OBJECT)Object; + LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p. Flags: %lx\n", Port, Port->Flags); + + /* Only Server-side Connection Ports need clean up*/ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CONNECTION_PORT) + { + /* Check the handle count */ + switch (SystemHandleCount) + { + /* No handles left */ + case 0: + + /* Destroy the port queue */ + LpcpDestroyPortQueue(Port, TRUE); + break; + + /* Last handle remaining */ + case 1: + + /* Reset the queue only */ + LpcpDestroyPortQueue(Port, FALSE); + + /* More handles remain, do nothing */ + default: + break; + } + } +} + +VOID +NTAPI +LpcpFreePortClientSecurity(IN PLPCP_PORT_OBJECT Port) +{ + /* Check if this is a client port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT) + { + /* Check if security is static */ + if (!(Port->Flags & LPCP_SECURITY_DYNAMIC)) + { + /* Check if we have a token */ + if (Port->StaticSecurity.ClientToken) + { + /* Free security */ + SeDeleteClientSecurity(&Port->StaticSecurity); + } + } + } +} + +VOID +NTAPI +LpcpDeletePort(IN PVOID ObjectBody) +{ + LARGE_INTEGER Timeout; + PETHREAD Thread; + PLPCP_PORT_OBJECT Port = (PLPCP_PORT_OBJECT)ObjectBody; + PLPCP_PORT_OBJECT ConnectionPort; + PLPCP_MESSAGE Message; + PLIST_ENTRY ListHead, NextEntry; + HANDLE Pid; + CLIENT_DIED_MSG ClientDiedMsg; + Timeout.QuadPart = -1000000; + PAGED_CODE(); + LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p. Flags: %lx\n", Port, Port->Flags); + + /* Check if this is a communication port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_COMMUNICATION_PORT) + { + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Get the thread */ + Thread = Port->ClientThread; + if (Thread) + { + /* Clear it */ + Port->ClientThread = NULL; + + /* Release the lock and dereference */ + KeReleaseGuardedMutex(&LpcpLock); + ObDereferenceObject(Thread); + } + else + { + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + } + } + + /* Check if this is a client-side port */ + if ((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CLIENT_PORT) + { + /* Setup the client died message */ + ClientDiedMsg.h.u1.s1.TotalLength = sizeof(ClientDiedMsg); + ClientDiedMsg.h.u1.s1.DataLength = sizeof(ClientDiedMsg.CreateTime); + ClientDiedMsg.h.u2.ZeroInit = LPC_PORT_CLOSED; + ClientDiedMsg.CreateTime = PsGetCurrentProcess()->CreateTime; + + /* Send it */ + for (;;) + { + /* Send the message */ + if (LpcRequestPort(Port, + &ClientDiedMsg.h) != STATUS_NO_MEMORY) break; + + /* Wait until trying again */ + KeDelayExecutionThread(KernelMode, FALSE, &Timeout); + } + } + + /* Destroy the port queue */ + LpcpDestroyPortQueue(Port, TRUE); + + /* Check if we had a client view */ + if (Port->ClientSectionBase) MmUnmapViewOfSection(PsGetCurrentProcess(), + Port->ClientSectionBase); + + /* Check for a server view */ + if (Port->ServerSectionBase) MmUnmapViewOfSection(PsGetCurrentProcess(), + Port->ServerSectionBase); + + /* Get the connection port */ + ConnectionPort = Port->ConnectionPort; + if (ConnectionPort) + { + /* Get the PID */ + Pid = PsGetCurrentProcessId(); + + /* Acquire the lock */ + KeAcquireGuardedMutex(&LpcpLock); + + /* Loop the data lists */ + ListHead = &ConnectionPort->LpcDataInfoChainHead; + NextEntry = ListHead->Flink; + while (NextEntry != ListHead) + { + /* Get the message */ + Message = CONTAINING_RECORD(NextEntry, LPCP_MESSAGE, Entry); + NextEntry = NextEntry->Flink; + + /* Check if the PID matches */ + if (Message->Request.ClientId.UniqueProcess == Pid) + { + /* Remove it */ + RemoveEntryList(&Message->Entry); + LpcpFreeToPortZone(Message, TRUE); + } + } + + /* Release the lock */ + KeReleaseGuardedMutex(&LpcpLock); + + /* Dereference the object unless it's the same port */ + if (ConnectionPort != Port) ObDereferenceObject(ConnectionPort); + } + + /* Check if this is a connection port with a server process*/ + if (((Port->Flags & LPCP_PORT_TYPE_MASK) == LPCP_CONNECTION_PORT) && + (ConnectionPort->ServerProcess)) + { + /* Dereference the server process */ + ObDereferenceObject(ConnectionPort->ServerProcess); + ConnectionPort->ServerProcess = NULL; + } + + /* Free client security */ + LpcpFreePortClientSecurity(Port); + LPCTRACE(LPC_CLOSE_DEBUG, "Port: %p deleted\n", Port); +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/complet… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/complete.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,47 @@ +/* +* PROJECT: ReactOS Kernel +* LICENSE: GPL - See COPYING in the top level directory +* FILE: ntoskrnl/lpc/complete.c +* PURPOSE: Local Procedure Call: Connection Completion +* PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) +*/ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PRIVATE FUNCTIONS *********************************************************/ + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtAcceptConnectPort(OUT PHANDLE PortHandle, + IN PVOID PortContext OPTIONAL, + IN PPORT_MESSAGE ReplyMessage, + IN BOOLEAN AcceptConnection, + IN PPORT_VIEW ClientView, + IN PREMOTE_PORT_VIEW ServerView) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtCompleteConnectPort(IN HANDLE PortHandle) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/connect… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/connect.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,65 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/connect.c + * PURPOSE: Local Procedure Call: Connection Management + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PRIVATE FUNCTIONS *********************************************************/ + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtSecureConnectPort(OUT PHANDLE PortHandle, + IN PUNICODE_STRING PortName, + IN PSECURITY_QUALITY_OF_SERVICE Qos, + IN OUT PPORT_VIEW ClientView OPTIONAL, + IN PSID ServerSid OPTIONAL, + IN OUT PREMOTE_PORT_VIEW ServerView OPTIONAL, + OUT PULONG MaxMessageLength OPTIONAL, + IN OUT PVOID ConnectionInformation OPTIONAL, + IN OUT PULONG ConnectionInformationLength OPTIONAL) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtConnectPort(OUT PHANDLE PortHandle, + IN PUNICODE_STRING PortName, + IN PSECURITY_QUALITY_OF_SERVICE Qos, + IN PPORT_VIEW ClientView, + IN PREMOTE_PORT_VIEW ServerView, + OUT PULONG MaxMessageLength, + IN PVOID ConnectionInformation, + OUT PULONG ConnectionInformationLength) +{ + /* Call the newer API */ + return NtSecureConnectPort(PortHandle, + PortName, + Qos, + ClientView, + NULL, + ServerView, + MaxMessageLength, + ConnectionInformation, + ConnectionInformationLength); +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/create.… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/create.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/create.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,77 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/create.c + * PURPOSE: Local Procedure Call: Port/Queue/Message Creation + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PRIVATE FUNCTIONS *********************************************************/ + +NTSTATUS +NTAPI +LpcpCreatePort(OUT PHANDLE PortHandle, + IN POBJECT_ATTRIBUTES ObjectAttributes, + IN ULONG MaxConnectionInfoLength, + IN ULONG MaxMessageLength, + IN ULONG MaxPoolUsage, + IN BOOLEAN Waitable) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtCreatePort(OUT PHANDLE PortHandle, + IN POBJECT_ATTRIBUTES ObjectAttributes, + IN ULONG MaxConnectInfoLength, + IN ULONG MaxDataLength, + IN ULONG MaxPoolUsage) +{ + PAGED_CODE(); + + /* Call the internal API */ + return LpcpCreatePort(PortHandle, + ObjectAttributes, + MaxConnectInfoLength, + MaxDataLength, + MaxPoolUsage, + FALSE); +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtCreateWaitablePort(OUT PHANDLE PortHandle, + IN POBJECT_ATTRIBUTES ObjectAttributes, + IN ULONG MaxConnectInfoLength, + IN ULONG MaxDataLength, + IN ULONG MaxPoolUsage) +{ + PAGED_CODE(); + + /* Call the internal API */ + return LpcpCreatePort(PortHandle, + ObjectAttributes, + MaxConnectInfoLength, + MaxDataLength, + MaxPoolUsage, + TRUE); +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/listen.… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/listen.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,31 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/listen.c + * PURPOSE: Local Procedure Call: Listening + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtListenPort(IN HANDLE PortHandle, + OUT PPORT_MESSAGE ConnectMessage) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h?r… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/lpc.h Mon Oct 30 17:28:50 2006 @@ -1,0 +1,216 @@ +/* +* PROJECT: ReactOS Kernel +* LICENSE: GPL - See COPYING in the top level directory +* FILE: ntoskrnl/include/lpc.h +* PURPOSE: Internal header for the Local Procedure Call +* PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) +*/ + +// +// Define this if you want debugging support +// +#define _LPC_DEBUG_ 0x01 + +// +// These define the Debug Masks Supported +// +#define LPC_CREATE_DEBUG 0x01 +#define LPC_CLOSE_DEBUG 0x02 +#define LPC_CONNECT_DEBUG 0x04 +#define LPC_LISTEN_DEBUG 0x08 +#define LPC_REPLY_DEBUG 0x10 +#define LPC_COMPLETE_DEBUG 0x20 +#define LPC_SEND_DEBUG 0x40 + +// +// Debug/Tracing support +// +#if _LPC_DEBUG_ +#ifdef NEW_DEBUG_SYSTEM_IMPLEMENTED // enable when Debug Filters are implemented +#define LPCTRACE(x, ...) \ + { \ + DbgPrintEx("%s [%.16s] - ", \ + __FUNCTION__, \ + PsGetCurrentProcess()->ImageFileName); \ + DbgPrintEx(__VA_ARGS__); \ + } +#else +#define LPCTRACE(x, ...) \ + if (x & LpcpTraceLevel) \ + { \ + DbgPrint("%s [%.16s:%lx] - ", \ + __FUNCTION__, \ + PsGetCurrentProcess()->ImageFileName, \ + PsGetCurrentThreadId()); \ + DbgPrint(__VA_ARGS__); \ + } +#endif +#endif + +// +// Gets the message type, removing the kernel-mode flag +// +#define LpcpGetMessageType(x) \ + ((x)->u2.s2.MessageType &~ LPCP_KERNEL_MESSAGE) + +// +// Waits on an LPC semaphore for a receive operation +// +#define LpcpReceiveWait(s, w) \ +{ \ + LPCTRACE(LPC_REPLY_DEBUG, "Wait: %p\n", s); \ + Status = KeWaitForSingleObject(s, \ + WrLpcReceive, \ + w, \ + FALSE, \ + NULL); \ + LPCTRACE(LPC_REPLY_DEBUG, "Wait done: %lx\n", Status); \ +} + +// +// Waits on an LPC semaphore for a reply operation +// +#define LpcpReplyWait(s, w) \ +{ \ + LPCTRACE(LPC_SEND_DEBUG, "Wait: %p\n", s); \ + Status = KeWaitForSingleObject(s, \ + WrLpcReply, \ + w, \ + FALSE, \ + NULL); \ + LPCTRACE(LPC_SEND_DEBUG, "Wait done: %lx\n", Status); \ + if (Status == STATUS_USER_APC) \ + { \ + /* We were preempted by an APC */ \ + if (KeReadStateSemaphore(s)) \ + { \ + /* It's still signaled, so wait on it */ \ + KeWaitForSingleObject(s, \ + Executive, \ + KernelMode, \ + FALSE, \ + NULL); \ + Status = STATUS_SUCCESS; \ + } \ + } \ +} + +// +// Waits on an LPC semaphore for a connect operation +// +#define LpcpConnectWait(s, w) \ +{ \ + LPCTRACE(LPC_CONNECT_DEBUG, "Wait: %p\n", s); \ + Status = KeWaitForSingleObject(s, \ + Executive, \ + w, \ + FALSE, \ + NULL); \ + LPCTRACE(LPC_CONNECT_DEBUG, "Wait done: %lx\n", Status);\ + if (Status == STATUS_USER_APC) \ + { \ + /* We were preempted by an APC */ \ + if (KeReadStateSemaphore(s)) \ + { \ + /* It's still signaled, so wait on it */ \ + KeWaitForSingleObject(s, \ + Executive, \ + KernelMode, \ + FALSE, \ + NULL); \ + Status = STATUS_SUCCESS; \ + } \ + } \ +} + +// +// Releases an LPC Semaphore to complete a wait +// +#define LpcpCompleteWait(s) \ +{ \ + /* Release the semaphore */ \ + LPCTRACE(LPC_SEND_DEBUG, "Release: %p\n", s); \ + KeReleaseSemaphore(s, 1, 1, FALSE); \ +} + +// +// Internal flag used for Kernel LPC Messages +// +#define LPCP_KERNEL_MESSAGE 0x8000 + +// +// Internal Port Management +// +VOID +NTAPI +LpcpClosePort( + IN PEPROCESS Process OPTIONAL, + IN PVOID Object, + IN ACCESS_MASK GrantedAccess, + IN ULONG ProcessHandleCount, + IN ULONG SystemHandleCount +); + +VOID +NTAPI +LpcpDeletePort( + IN PVOID ObjectBody +); + +NTSTATUS +NTAPI +LpcpInitializePortQueue( + IN PLPCP_PORT_OBJECT Port +); + +VOID +NTAPI +LpcpFreeToPortZone( + IN PLPCP_MESSAGE Message, + IN ULONG Flags +); + +VOID +NTAPI +LpcpMoveMessage( + IN PPORT_MESSAGE Destination, + IN PPORT_MESSAGE Origin, + IN PVOID Data, + IN ULONG MessageType, + IN PCLIENT_ID ClientId +); + +VOID +NTAPI +LpcpSaveDataInfoMessage( + IN PLPCP_PORT_OBJECT Port, + IN PLPCP_MESSAGE Message +); + +// +// Module-external utlity functions +// +VOID +NTAPI +LpcExitThread( + IN PETHREAD Thread +); + +// +// Initialization functions +// +NTSTATUS +NTAPI +LpcpInitSystem( + VOID +); + +// +// Global data inside the Process Manager +// +extern POBJECT_TYPE LpcPortObjectType; +extern ULONG LpcpNextMessageId, LpcpNextCallbackId; +extern KGUARDED_MUTEX LpcpLock; +extern PAGED_LOOKASIDE_LIST LpcpMessagesLookaside; +extern ULONG LpcpMaxMessageSize; +extern ULONG LpcpTraceLevel; Added: trunk/reactos/ntoskrnl/lpc/ntlpc/port.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/port.c?… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/port.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/port.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,108 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/port.c + * PURPOSE: Local Procedure Call: Port Management + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* GLOBALS *******************************************************************/ + +POBJECT_TYPE LpcPortObjectType; +ULONG LpcpMaxMessageSize; +PAGED_LOOKASIDE_LIST LpcpMessagesLookaside; +KGUARDED_MUTEX LpcpLock; +ULONG LpcpTraceLevel = 0xFFFFFFFF; +ULONG LpcpNextMessageId = 1, LpcpNextCallbackId = 1; + +static GENERIC_MAPPING LpcpPortMapping = +{ + STANDARD_RIGHTS_READ, + STANDARD_RIGHTS_WRITE, + 0, + PORT_ALL_ACCESS +}; + +/* PRIVATE FUNCTIONS *********************************************************/ + +NTSTATUS +INIT_FUNCTION +NTAPI +LpcpInitSystem(VOID) +{ + OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; + UNICODE_STRING Name; + + /* Setup the LPC Lock */ + KeInitializeGuardedMutex(&LpcpLock); + + /* Create the Port Object Type */ + RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); + RtlInitUnicodeString(&Name, L"Port"); + ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer); + ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(LPCP_PORT_OBJECT); + ObjectTypeInitializer.DefaultPagedPoolCharge = sizeof(LPCP_NONPAGED_PORT_QUEUE); + ObjectTypeInitializer.GenericMapping = LpcpPortMapping; + ObjectTypeInitializer.PoolType = PagedPool; + ObjectTypeInitializer.UseDefaultObject = TRUE; + ObjectTypeInitializer.CloseProcedure = LpcpClosePort; + ObjectTypeInitializer.DeleteProcedure = LpcpDeletePort; + ObjectTypeInitializer.ValidAccessMask = PORT_ALL_ACCESS; + ObCreateObjectType(&Name, + &ObjectTypeInitializer, + NULL, + &LpcPortObjectType); + + /* Allocate the LPC lookaside list */ + LpcpMaxMessageSize = LPCP_MAX_MESSAGE_SIZE; + ExInitializePagedLookasideList(&LpcpMessagesLookaside, + NULL, + NULL, + 0, + LpcpMaxMessageSize, + TAG('L', 'p', 'c', 'M'), + 32); + + /* We're done */ + return STATUS_SUCCESS; +} + +/* PUBLIC FUNCTIONS **********************************************************/ + +NTSTATUS +NTAPI +NtImpersonateClientOfPort(IN HANDLE PortHandle, + IN PPORT_MESSAGE ClientMessage) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +NTSTATUS +NTAPI +NtQueryPortInformationProcess(VOID) +{ + /* This is all this function does */ + return STATUS_UNSUCCESSFUL; +} + +NTSTATUS +NTAPI +NtQueryInformationPort(IN HANDLE PortHandle, + IN PORT_INFORMATION_CLASS PortInformationClass, + OUT PVOID PortInformation, + IN ULONG PortInformationLength, + OUT PULONG ReturnLength) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/reply.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,109 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/reply.c + * PURPOSE: Local Procedure Call: Receive (Replies) + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PRIVATE FUNCTIONS *********************************************************/ + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtReplyPort(IN HANDLE PortHandle, + IN PPORT_MESSAGE LpcReply) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtReplyWaitReceivePortEx(IN HANDLE PortHandle, + OUT PVOID *PortContext OPTIONAL, + IN PPORT_MESSAGE ReplyMessage OPTIONAL, + OUT PPORT_MESSAGE ReceiveMessage, + IN PLARGE_INTEGER Timeout OPTIONAL) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtReplyWaitReceivePort(IN HANDLE PortHandle, + OUT PVOID *PortContext OPTIONAL, + IN PPORT_MESSAGE ReplyMessage OPTIONAL, + OUT PPORT_MESSAGE ReceiveMessage) +{ + /* Call the newer API */ + return NtReplyWaitReceivePortEx(PortHandle, + PortContext, + ReplyMessage, + ReceiveMessage, + NULL); +} + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtReplyWaitReplyPort(IN HANDLE PortHandle, + IN PPORT_MESSAGE ReplyMessage) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtReadRequestData(IN HANDLE PortHandle, + IN PPORT_MESSAGE Message, + IN ULONG Index, + IN PVOID Buffer, + IN ULONG BufferLength, + OUT PULONG Returnlength) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtWriteRequestData(IN HANDLE PortHandle, + IN PPORT_MESSAGE Message, + IN ULONG Index, + IN PVOID Buffer, + IN ULONG BufferLength, + OUT PULONG ReturnLength) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* EOF */ Added: trunk/reactos/ntoskrnl/lpc/ntlpc/send.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/ntlpc/send.c?… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/ntlpc/send.c (added) +++ trunk/reactos/ntoskrnl/lpc/ntlpc/send.c Mon Oct 30 17:28:50 2006 @@ -1,0 +1,68 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/lpc/send.c + * PURPOSE: Local Procedure Call: Sending (Requests) + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#include "lpc.h" +#define NDEBUG +#include <internal/debug.h> + +/* PUBLIC FUNCTIONS **********************************************************/ + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +LpcRequestPort(IN PVOID Port, + IN PPORT_MESSAGE LpcMessage) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* +* @unimplemented +*/ +NTSTATUS +NTAPI +LpcRequestWaitReplyPort(IN PVOID Port, + IN PPORT_MESSAGE LpcMessageRequest, + OUT PPORT_MESSAGE LpcMessageReply) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @unimplemented + */ +NTSTATUS +NTAPI +NtRequestPort(IN HANDLE PortHandle, + IN PPORT_MESSAGE LpcMessage) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +NtRequestWaitReplyPort(IN HANDLE PortHandle, + IN PPORT_MESSAGE LpcRequest, + IN OUT PPORT_MESSAGE LpcReply) +{ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* EOF */

18 years, 1 month

[ion] 24665: - Implement the rest of Hard Error support. - Kernel support is complete (except temporary LPC hack), and CSRSS properly receives the event and sends it off to win32csr's hard error handler (much like on NT). However, the handler doesn't call NtUserHardErrorControl nor do much of the complex sequence of events that NT does, instead, we only display a hello-world style message box. Anyone up for implementing the rest is welcome.

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:20:45 2006 New Revision: 24665 URL: http://svn.reactos.org/svn/reactos?rev=24665&view=rev Log: - Implement the rest of Hard Error support. - Kernel support is complete (except temporary LPC hack), and CSRSS properly receives the event and sends it off to win32csr's hard error handler (much like on NT). However, the handler doesn't call NtUserHardErrorControl nor do much of the complex sequence of events that NT does, instead, we only display a hello-world style message box. Anyone up for implementing the rest is welcome. Modified: trunk/reactos/ntoskrnl/ex/error.c trunk/reactos/ntoskrnl/lpc/reply.c trunk/reactos/ntoskrnl/lpc/send.c trunk/reactos/subsystems/win32/csrss/api/wapi.c trunk/reactos/subsystems/win32/csrss/include/csrplugin.h trunk/reactos/subsystems/win32/csrss/init.c trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c trunk/reactos/subsystems/win32/csrss/win32csr/win32csr.def Modified: trunk/reactos/ntoskrnl/ex/error.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ex/error.c?rev=24… ============================================================================== --- trunk/reactos/ntoskrnl/ex/error.c (original) +++ trunk/reactos/ntoskrnl/ex/error.c Mon Oct 30 17:20:45 2006 @@ -112,11 +112,6 @@ HANDLE PortHandle; KPROCESSOR_MODE PreviousMode = KeGetPreviousMode(); PAGED_CODE(); - DPRINT1("Hard error, baby!: %lx, %lx, %lx %p\n", - ErrorStatus, - NumberOfParameters, - UnicodeStringParameterMask, - Parameters); /* Check if this error will shutdown the system */ if (ValidResponseOptions == OptionShutdownSystem) @@ -235,15 +230,42 @@ Parameters, sizeof(ULONG_PTR) * NumberOfParameters); - /* Send the message */ + /* Send the LPC Message */ Status = LpcRequestWaitReplyPort(PortHandle, (PVOID)Message, (PVOID)Message); - DPRINT1("Checkpoint 2: %lx\n", Status); - } - - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + if (NT_SUCCESS(Status)) + { + /* Check what kind of response we got */ + if ((Message->Response != ResponseReturnToCaller) && + (Message->Response != ResponseNotHandled) && + (Message->Response != ResponseAbort) && + (Message->Response != ResponseCancel) && + (Message->Response != ResponseIgnore) && + (Message->Response != ResponseNo) && + (Message->Response != ResponseOk) && + (Message->Response != ResponseRetry) && + (Message->Response != ResponseYes) && + (Message->Response != ResponseTryAgain) && + (Message->Response != ResponseContinue)) + { + /* Reset to a default one */ + Message->Response = ResponseReturnToCaller; + } + + /* Set the response */ + *Response = Message->Response; + } + } + else + { + /* Set defaults */ + *Response = ResponseReturnToCaller; + Status = STATUS_SUCCESS; + } + + /* Return status */ + return Status; } /*++ Modified: trunk/reactos/ntoskrnl/lpc/reply.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/reply.c?rev=2… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/reply.c (original) +++ trunk/reactos/ntoskrnl/lpc/reply.c Mon Oct 30 17:20:45 2006 @@ -429,22 +429,26 @@ { HANDLE PortHandle; NTSTATUS Status; - - /* This is a SICK hack */ - Status = ObOpenObjectByPointer(Port, - 0, - NULL, - PORT_ALL_ACCESS, - LpcPortObjectType, - KernelMode, - &PortHandle); - DPRINT1("LPC Hack active: %lx %lx\n", Status, PortHandle); - - /* Call the Nt function. Do a ring transition to get Kmode. */ + UNICODE_STRING PortName; + ULONG ConnectInfoLength; + + // + // OMG HAXX! + // + RtlInitUnicodeString(&PortName, L"\\Windows\\ApiPort"); + ConnectInfoLength = 0; + Status = ZwConnectPort(&PortHandle, + &PortName, + NULL, + NULL, + NULL, + NULL, + NULL, + &ConnectInfoLength); + Status = ZwRequestWaitReplyPort(PortHandle, LpcMessageRequest, LpcMessageReply); - DPRINT1("LPC Hack active: %lx %lx\n", Status, PortHandle); /* Close the handle */ ObCloseHandle(PortHandle, KernelMode); Modified: trunk/reactos/ntoskrnl/lpc/send.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/send.c?rev=24… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/send.c (original) +++ trunk/reactos/ntoskrnl/lpc/send.c Mon Oct 30 17:20:45 2006 @@ -288,7 +288,7 @@ Status = EiReplyOrRequestPort(Port->OtherPort, LpcRequest, - LPC_REQUEST, + LpcRequest->u2.s2.Type == LPC_ERROR_EVENT ? LPC_ERROR_EVENT : LPC_REQUEST, Port); if (!NT_SUCCESS(Status)) { Modified: trunk/reactos/subsystems/win32/csrss/api/wapi.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/api… ============================================================================== --- trunk/reactos/subsystems/win32/csrss/api/wapi.c (original) +++ trunk/reactos/subsystems/win32/csrss/api/wapi.c Mon Oct 30 17:20:45 2006 @@ -104,6 +104,20 @@ } } +BOOL FASTCALL CallHardError(void); + +static +VOID +NTAPI +CsrHandleHardError(IN PCSRSS_PROCESS_DATA ProcessData, + IN OUT PHARDERROR_MSG Message) +{ + DPRINT1("CSR: received hard error %lx\n", Message->Status); + + /* Call the hard error handler in win32csr */ + CallHardError(); +} + static VOID STDCALL @@ -133,7 +147,7 @@ DPRINT1("NtReplyWaitReceivePort failed\n"); break; } - + /* If the connection was closed, handle that */ if (Request->Header.u2.s2.Type == LPC_PORT_CLOSED) { @@ -161,9 +175,18 @@ continue; } - /* Call the Handler */ - CsrApiCallHandler(ProcessData, Request); - + /* Check if we got a hard error */ + if (Request->Header.u2.s2.Type == LPC_ERROR_EVENT) + { + /* Call the Handler */ + CsrHandleHardError(ProcessData, (PHARDERROR_MSG)Request); + } + else + { + /* Call the Handler */ + CsrApiCallHandler(ProcessData, Request); + } + /* Send back the reply */ Reply = Request; } Modified: trunk/reactos/subsystems/win32/csrss/include/csrplugin.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/inc… ============================================================================== --- trunk/reactos/subsystems/win32/csrss/include/csrplugin.h (original) +++ trunk/reactos/subsystems/win32/csrss/include/csrplugin.h Mon Oct 30 17:20:45 2006 @@ -43,9 +43,12 @@ typedef BOOL (STDCALL *CSRPLUGIN_INIT_COMPLETE_PROC)(void); +typedef BOOL (STDCALL *CSRPLUGIN_HARDERROR_PROC)(void); + typedef BOOL (STDCALL *CSRPLUGIN_INITIALIZE_PROC)(PCSRSS_API_DEFINITION *ApiDefinitions, PCSRSS_OBJECT_DEFINITION *ObjectDefinitions, CSRPLUGIN_INIT_COMPLETE_PROC *InitCompleteProc, + CSRPLUGIN_HARDERROR_PROC *HardErrorProc, PCSRSS_EXPORTED_FUNCS Exports, HANDLE CsrssApiHeap); Modified: trunk/reactos/subsystems/win32/csrss/init.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/ini… ============================================================================== --- trunk/reactos/subsystems/win32/csrss/init.c (original) +++ trunk/reactos/subsystems/win32/csrss/init.c Mon Oct 30 17:20:45 2006 @@ -27,6 +27,9 @@ static unsigned InitCompleteProcCount; static CSRPLUGIN_INIT_COMPLETE_PROC *InitCompleteProcs = NULL; + +static unsigned HardErrorProcCount; +static CSRPLUGIN_HARDERROR_PROC *HardErrorProcs = NULL; HANDLE hSbApiPort = (HANDLE) 0; @@ -64,6 +67,34 @@ InitCompleteProcCount++; return STATUS_SUCCESS; +} + +static NTSTATUS FASTCALL +CsrpAddHardErrorProc(CSRPLUGIN_HARDERROR_PROC Proc) +{ + CSRPLUGIN_HARDERROR_PROC *NewProcs; + + DPRINT("CSR: %s called\n", __FUNCTION__); + + NewProcs = RtlAllocateHeap(CsrssApiHeap, 0, + (HardErrorProcCount + 1) + * sizeof(CSRPLUGIN_HARDERROR_PROC)); + if (NULL == NewProcs) + { + return STATUS_NO_MEMORY; + } + if (0 != HardErrorProcCount) + { + RtlCopyMemory(NewProcs, HardErrorProcs, + HardErrorProcCount * sizeof(CSRPLUGIN_HARDERROR_PROC)); + RtlFreeHeap(CsrssApiHeap, 0, HardErrorProcs); + } + + NewProcs[HardErrorProcCount] = Proc; + HardErrorProcs = NewProcs; + HardErrorProcCount++; + + return STATUS_SUCCESS; } /********************************************************************** @@ -88,6 +119,27 @@ } return Ok; +} + +BOOL +FASTCALL +CallHardError(void) +{ + BOOL Ok; + unsigned i; + + DPRINT("CSR: %s called\n", __FUNCTION__); + + Ok = TRUE; + if (0 != HardErrorProcCount) + { + for (i = 0; i < HardErrorProcCount && Ok; i++) + { + Ok = (*(HardErrorProcs[i]))(); + } + } + + return Ok; } ULONG @@ -182,6 +234,7 @@ PCSRSS_API_DEFINITION ApiDefinitions; PCSRSS_OBJECT_DEFINITION ObjectDefinitions; CSRPLUGIN_INIT_COMPLETE_PROC InitCompleteProc; + CSRPLUGIN_HARDERROR_PROC HardErrorProc; DPRINT("CSR: %s called\n", __FUNCTION__); @@ -202,7 +255,7 @@ Exports.CsrReleaseObjectProc = CsrReleaseObject; Exports.CsrEnumProcessesProc = CsrEnumProcesses; if (! (*InitProc)(&ApiDefinitions, &ObjectDefinitions, &InitCompleteProc, - &Exports, CsrssApiHeap)) + &HardErrorProc, &Exports, CsrssApiHeap)) { return STATUS_UNSUCCESSFUL; } @@ -221,6 +274,7 @@ { Status = CsrpAddInitCompleteProc(InitCompleteProc); } + if (HardErrorProc) Status = CsrpAddHardErrorProc(HardErrorProc); return Status; } Modified: trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/win… ============================================================================== --- trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c (original) +++ trunk/reactos/subsystems/win32/csrss/win32csr/dllmain.c Mon Oct 30 17:20:45 2006 @@ -163,10 +163,19 @@ return TRUE; } +static BOOL STDCALL +Win32CsrHardError(void) +{ + MessageBox(0, "Hard Error", "TODO", 0); + return TRUE; +} + + BOOL STDCALL Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions, PCSRSS_OBJECT_DEFINITION *ObjectDefinitions, CSRPLUGIN_INIT_COMPLETE_PROC *InitComplete, + CSRPLUGIN_HARDERROR_PROC *HardError, PCSRSS_EXPORTED_FUNCS Exports, HANDLE CsrssApiHeap) { @@ -179,6 +188,7 @@ *ApiDefinitions = Win32CsrApiDefinitions; *ObjectDefinitions = Win32CsrObjectDefinitions; *InitComplete = Win32CsrInitComplete; + *HardError = Win32CsrHardError; return TRUE; } Modified: trunk/reactos/subsystems/win32/csrss/win32csr/win32csr.def URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/csrss/win… ============================================================================== --- trunk/reactos/subsystems/win32/csrss/win32csr/win32csr.def (original) +++ trunk/reactos/subsystems/win32/csrss/win32csr/win32csr.def Mon Oct 30 17:20:45 2006 @@ -5,4 +5,4 @@ EXPORTS -Win32CsrInitialization@20 +Win32CsrInitialization@24

18 years, 1 month

[ion] 24664: - SMSS: Send QOS structure when creating new ports, it's not optional on NT LPC. Send maximum port length when creating new ports, it's not optional on NT LPC. Create 2 listening threads on NTLPC, instead of just one. [AUDIT: Unlock smlib, it's fully internal and specific to ROS without any relationship to NT. The author used clean-room tests and documentation]. - Fix various LPC structures in the NDK. Fix some prototypes too. - Don't export PEPORT or PLPCP_PORT_OBJECT outside of /l

by ion＠svn.reactos.org

Author: ion Date: Mon Oct 30 17:17:37 2006 New Revision: 24664 URL: http://svn.reactos.org/svn/reactos?rev=24664&view=rev Log: - SMSS: Send QOS structure when creating new ports, it's not optional on NT LPC. Send maximum port length when creating new ports, it's not optional on NT LPC. Create 2 listening threads on NTLPC, instead of just one. [AUDIT: Unlock smlib, it's fully internal and specific to ROS without any relationship to NT. The author used clean-room tests and documentation]. - Fix various LPC structures in the NDK. Fix some prototypes too. - Don't export PEPORT or PLPCP_PORT_OBJECT outside of /lpc and use PVOID isntead. - Add a new RBUILD setting called NTLPC, which enables NTLPC when turned on. Modified: trunk/reactos/base/system/smss/debug.c trunk/reactos/base/system/smss/smapi.c trunk/reactos/base/system/smss/smss.rbuild trunk/reactos/include/ndk/extypes.h trunk/reactos/include/ndk/lpcfuncs.h trunk/reactos/include/ndk/lpctypes.h trunk/reactos/include/ndk/psfuncs.h trunk/reactos/lib/smlib/compses.c (props changed) trunk/reactos/lib/smlib/connect.c (contents, props changed) trunk/reactos/lib/smlib/execpgm.c (props changed) trunk/reactos/lib/smlib/lookupss.c (props changed) trunk/reactos/lib/smlib/precomp.h (props changed) trunk/reactos/ntoskrnl/ex/error.c trunk/reactos/ntoskrnl/include/internal/lpc.h trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h trunk/reactos/ntoskrnl/lpc/send.c trunk/reactos/ntoskrnl/ntoskrnl.rbuild trunk/reactos/ntoskrnl/ps/process.c trunk/reactos/ntoskrnl/ps/query.c Modified: trunk/reactos/base/system/smss/debug.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/smss/debug.c?r… ============================================================================== --- trunk/reactos/base/system/smss/debug.c (original) +++ trunk/reactos/base/system/smss/debug.c Mon Oct 30 17:17:37 2006 @@ -153,7 +153,7 @@ Status = SmpCreatePT(& DbgSsApiPort, SM_DBGSS_PORT_NAME, 0, /* MaxDataSize */ - 0, /* MaxMessageSize */ + sizeof(PORT_MESSAGE), /* MaxMessageSize */ 0, /* PoolCharge */ DbgSsApiPortThread, & hDbgSsApiPortThread); @@ -166,7 +166,7 @@ Status = SmpCreatePT(& DbgUiApiPort, SM_DBGUI_PORT_NAME, 0, /* MaxDataSize */ - 0, /* MaxMessageSize */ + sizeof(PORT_MESSAGE), /* MaxMessageSize */ 0, /* PoolCharge */ DbgUiApiPortThread, NULL); Modified: trunk/reactos/base/system/smss/smapi.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/smss/smapi.c?r… ============================================================================== --- trunk/reactos/base/system/smss/smapi.c (original) +++ trunk/reactos/base/system/smss/smapi.c Mon Oct 30 17:17:37 2006 @@ -44,10 +44,8 @@ return (PSM_CONNECT_DATA)(PortMessage + 1); } -#if !defined(__USE_NT_LPC__) NTSTATUS STDCALL SmpHandleConnectionRequest (PSM_PORT_MESSAGE Request); -#endif /********************************************************************** * SmpCallbackServer/2 @@ -68,6 +66,7 @@ ULONG CallbackPortNameLength = SM_SB_NAME_MAX_LENGTH; /* TODO: compute length */ SB_CONNECT_DATA SbConnectData; ULONG SbConnectDataLength = sizeof SbConnectData; + SECURITY_QUALITY_OF_SERVICE SecurityQos; DPRINT("SM: %s called\n", __FUNCTION__); @@ -84,10 +83,15 @@ RtlInitUnicodeString (& CallbackPortName, ClientData->SbApiPortName); + SecurityQos.Length = sizeof (SecurityQos); + SecurityQos.ImpersonationLevel = SecurityIdentification; + SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; + SecurityQos.EffectiveOnly = TRUE; + SbConnectData.SmApiMax = (sizeof SmApi / sizeof SmApi[0]); Status = NtConnectPort (& ClientData->SbApiPort, & CallbackPortName, - NULL, + &SecurityQos, NULL, NULL, NULL, @@ -245,7 +249,7 @@ } } DPRINT("SM: %s: before NtAcceptConnectPort\n", __FUNCTION__); -#if defined(__USE_NT_LPC__) +#if defined(NTLPC) Status = NtAcceptConnectPort (ClientDataApiPort, Context, (PPORT_MESSAGE) Request, @@ -276,7 +280,7 @@ __FUNCTION__, Status); return Status; } -#if !defined(__USE_NT_LPC__) /* ReactOS LPC */ +#if !defined(NTLPC) /* ReactOS LPC */ DPRINT("SM: %s: server side comm port thread (ROS LPC)\n", __FUNCTION__); Status = RtlCreateUserThread(NtCurrentProcess(), NULL, @@ -369,8 +373,8 @@ Status = NtCreatePort(&SmApiPort, &ObjectAttributes, - 0, - 0, + sizeof(SM_CONNECT_DATA), + sizeof(SM_PORT_MESSAGE), 0); if (!NT_SUCCESS(Status)) { @@ -386,11 +390,35 @@ 0, 0, 0, +#ifdef NTLPC + (PTHREAD_START_ROUTINE)SmpApiConnectedThread, + &SmApiPort, +#else (PTHREAD_START_ROUTINE)SmpApiThread, (PVOID)SmApiPort, +#endif NULL, NULL); +#ifdef NTLPC + // + // On NT LPC, we need a second thread to handle incoming connections + // generated by incoming requests, otherwise the thread handling + // the request will be busy sending the LPC message, without any other + // thread being busy to receive the LPC message. + // + Status = RtlCreateUserThread(NtCurrentProcess(), + NULL, + FALSE, + 0, + 0, + 0, + (PTHREAD_START_ROUTINE)SmpApiConnectedThread, + &SmApiPort, + NULL, + NULL); +#endif + return(Status); } Modified: trunk/reactos/base/system/smss/smss.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/smss/smss.rbui… ============================================================================== --- trunk/reactos/base/system/smss/smss.rbuild (original) +++ trunk/reactos/base/system/smss/smss.rbuild Mon Oct 30 17:17:37 2006 @@ -3,6 +3,9 @@ <include base="ReactOS">include/reactos/subsys</include> <define name="__USE_W32API" /> <define name="_DISABLE_TIDENTS" /> + <if property="NTLPC" value="1"> + <define name="NTLPC" /> + </if> <library>nt</library> <library>smlib</library> <library>ntdll</library> Modified: trunk/reactos/include/ndk/extypes.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/extypes.h?rev=… ============================================================================== --- trunk/reactos/include/ndk/extypes.h (original) +++ trunk/reactos/include/ndk/extypes.h Mon Oct 30 17:17:37 2006 @@ -185,7 +185,9 @@ ResponseNo, ResponseOk, ResponseRetry, - ResponseYes + ResponseYes, + ResponseTryAgain, + ResponseContinue } HARDERROR_RESPONSE, *PHARDERROR_RESPONSE; // Modified: trunk/reactos/include/ndk/lpcfuncs.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/lpcfuncs.h?rev… ============================================================================== --- trunk/reactos/include/ndk/lpcfuncs.h (original) +++ trunk/reactos/include/ndk/lpcfuncs.h Mon Oct 30 17:17:37 2006 @@ -34,8 +34,15 @@ LpcRequestWaitReplyPort( IN PVOID Port, IN PPORT_MESSAGE LpcMessageRequest, - OUT PPORT_MESSAGE LpcMessageReply) -; + OUT PPORT_MESSAGE LpcMessageReply +); + +NTSTATUS +NTAPI +LpcRequestPort( + IN PVOID Port, + IN PPORT_MESSAGE LpcMessage +); #endif // Modified: trunk/reactos/include/ndk/lpctypes.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/lpctypes.h?rev… ============================================================================== --- trunk/reactos/include/ndk/lpctypes.h (original) +++ trunk/reactos/include/ndk/lpctypes.h Mon Oct 30 17:17:37 2006 @@ -39,7 +39,21 @@ // // Port Object Access Masks // +#define PORT_CONNECT 0x1 #define PORT_ALL_ACCESS 0x1 + +// +// Port Object Flags +// +#define LPCP_CONNECTION_PORT 0x00000001 +#define LPCP_UNCONNECTED_PORT 0x00000002 +#define LPCP_COMMUNICATION_PORT 0x00000003 +#define LPCP_CLIENT_PORT 0x00000004 +#define LPCP_PORT_TYPE_MASK 0x0000000F +#define LPCP_PORT_DELETED 0x10000000 +#define LPCP_WAITABLE_PORT 0x20000000 +#define LPCP_NAME_DELETED 0x40000000 +#define LPCP_SECURITY_DYNAMIC 0x80000000 // // LPC Message Types @@ -170,7 +184,7 @@ typedef struct _LPCP_PORT_QUEUE { PLPCP_NONPAGED_PORT_QUEUE NonPagedPortQueue; - KSEMAPHORE Semaphore; + PKSEMAPHORE Semaphore; LIST_ENTRY ReceiveHead; } LPCP_PORT_QUEUE, *PLPCP_PORT_QUEUE; @@ -179,8 +193,6 @@ // typedef struct _LPCP_PORT_OBJECT { - ULONG Length; - ULONG Flags; struct _LPCP_PORT_OBJECT *ConnectionPort; struct _LPCP_PORT_OBJECT *ConnectedPort; LPCP_PORT_QUEUE MsgQueue; @@ -188,13 +200,17 @@ PVOID ClientSectionBase; PVOID ServerSectionBase; PVOID PortContext; - ULONG MaxMessageLength; - ULONG MaxConnectionInfoLength; PETHREAD ClientThread; SECURITY_QUALITY_OF_SERVICE SecurityQos; SECURITY_CLIENT_CONTEXT StaticSecurity; LIST_ENTRY LpcReplyChainHead; LIST_ENTRY LpcDataInfoChainHead; + PEPROCESS ServerProcess; + PEPROCESS MappingProcess; + ULONG MaxMessageLength; + ULONG MaxConnectionInfoLength; + ULONG Flags; + KEVENT WaitEvent; } LPCP_PORT_OBJECT, *PLPCP_PORT_OBJECT; // Modified: trunk/reactos/include/ndk/psfuncs.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/psfuncs.h?rev=… ============================================================================== --- trunk/reactos/include/ndk/psfuncs.h (original) +++ trunk/reactos/include/ndk/psfuncs.h Mon Oct 30 17:17:37 2006 @@ -109,6 +109,14 @@ HANDLE NTAPI PsGetProcessId(PEPROCESS Process); + +NTSTATUS +NTAPI +PsLookupProcessThreadByCid( + IN PCLIENT_ID Cid, + OUT PEPROCESS *Process OPTIONAL, + OUT PETHREAD *Thread +); #endif Propchange: trunk/reactos/lib/smlib/compses.c ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Modified: trunk/reactos/lib/smlib/connect.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/smlib/connect.c?rev=24… ============================================================================== --- trunk/reactos/lib/smlib/connect.c (original) +++ trunk/reactos/lib/smlib/connect.c Mon Oct 30 17:17:37 2006 @@ -78,7 +78,7 @@ SecurityQos.Length = sizeof (SecurityQos); SecurityQos.ImpersonationLevel = SecurityIdentification; - SecurityQos.ContextTrackingMode = TRUE; + SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; SecurityQos.EffectiveOnly = TRUE; RtlInitUnicodeString (& SmApiPortName, SM_API_PORT_NAME); Propchange: trunk/reactos/lib/smlib/connect.c ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Propchange: trunk/reactos/lib/smlib/execpgm.c ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Propchange: trunk/reactos/lib/smlib/lookupss.c ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Propchange: trunk/reactos/lib/smlib/precomp.h ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Modified: trunk/reactos/ntoskrnl/ex/error.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ex/error.c?rev=24… ============================================================================== --- trunk/reactos/ntoskrnl/ex/error.c (original) +++ trunk/reactos/ntoskrnl/ex/error.c Mon Oct 30 17:17:37 2006 @@ -17,7 +17,7 @@ /* GLOBALS ****************************************************************/ BOOLEAN ExReadyForErrors = FALSE; -PEPORT ExpDefaultErrorPort = NULL; +PVOID ExpDefaultErrorPort = NULL; PEPROCESS ExpDefaultErrorPortProcess = NULL; /* FUNCTIONS ****************************************************************/ Modified: trunk/reactos/ntoskrnl/include/internal/lpc.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/include/internal/… ============================================================================== --- trunk/reactos/ntoskrnl/include/internal/lpc.h (original) +++ trunk/reactos/ntoskrnl/include/internal/lpc.h Mon Oct 30 17:17:37 2006 @@ -20,7 +20,9 @@ extern POBJECT_TYPE LpcPortObjectType; extern ULONG LpcpNextMessageId; +#ifndef NTLPC extern FAST_MUTEX LpcpLock; +#endif typedef struct _EPORT_LISTENER { @@ -73,13 +75,6 @@ LIST_ENTRY QueueListEntry; PORT_MESSAGE Message; } QUEUEDMESSAGE, *PQUEUEDMESSAGE; - -NTSTATUS -NTAPI -LpcRequestPort( - PEPORT Port, - PPORT_MESSAGE LpcMessage -); NTSTATUS NTAPI Modified: trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/include/internal/… ============================================================================== --- trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h (original) +++ trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h Mon Oct 30 17:17:37 2006 @@ -175,7 +175,7 @@ { NTSTATUS Status = STATUS_SUCCESS; - if (Class >= 0 && Class < ClassListEntries) + if (Class < ClassListEntries) { if (!(ClassList[Class].Flags & ICIF_SET)) { @@ -226,7 +226,7 @@ { NTSTATUS Status = STATUS_SUCCESS; - if (Class >= 0 && Class < ClassListEntries) + if (Class < ClassListEntries) { if (!(ClassList[Class].Flags & ICIF_QUERY)) { Modified: trunk/reactos/ntoskrnl/lpc/send.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/lpc/send.c?rev=24… ============================================================================== --- trunk/reactos/ntoskrnl/lpc/send.c (original) +++ trunk/reactos/ntoskrnl/lpc/send.c Mon Oct 30 17:17:37 2006 @@ -34,10 +34,11 @@ * * @implemented */ -NTSTATUS STDCALL LpcRequestPort (IN PEPORT Port, +NTSTATUS STDCALL LpcRequestPort (IN PVOID PortObject, IN PPORT_MESSAGE LpcMessage) { NTSTATUS Status; + PEPORT Port = (PEPORT)PortObject; DPRINT("LpcRequestPort(PortHandle %08x, LpcMessage %08x)\n", Port, LpcMessage); Modified: trunk/reactos/ntoskrnl/ntoskrnl.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ntoskrnl.rbuild?r… ============================================================================== --- trunk/reactos/ntoskrnl/ntoskrnl.rbuild (original) +++ trunk/reactos/ntoskrnl/ntoskrnl.rbuild Mon Oct 30 17:17:37 2006 @@ -9,6 +9,9 @@ <define name="__NO_CTYPE_INLINES" /> <define name="__USE_W32API" /> <define name="WIN9X_COMPAT_SPINLOCK" /> + <if property="NTLPC" value="1"> + <define name="NTLPC" /> + </if> <include base="cmlib">.</include> <include base="ntoskrnl">include</include> <include base="ReactOS">include/reactos/drivers</include> @@ -220,19 +223,35 @@ <file>loader.c</file> <file>rtl.c</file> </directory> - <directory name="lpc"> - <file>close.c</file> - <file>complete.c</file> - <file>connect.c</file> - <file>create.c</file> - <file>listen.c</file> - <file>port.c</file> - <file>query.c</file> - <file>queue.c</file> - <file>receive.c</file> - <file>reply.c</file> - <file>send.c</file> - </directory> + <if property="NTLPC" value="0"> + <directory name="lpc"> + <file>close.c</file> + <file>complete.c</file> + <file>connect.c</file> + <file>create.c</file> + <file>listen.c</file> + <file>port.c</file> + <file>query.c</file> + <file>queue.c</file> + <file>receive.c</file> + <file>reply.c</file> + <file>send.c</file> + </directory> + </if> + <if property="NTLPC" value="1"> + <directory name="lpc"> + <directory name="ntlpc"> + <file>close.c</file> + <file>complete.c</file> + <file>connect.c</file> + <file>create.c</file> + <file>listen.c</file> + <file>port.c</file> + <file>reply.c</file> + <file>send.c</file> + </directory> + </directory> + </if> <directory name="mm"> <if property="ARCH" value="i386"> <directory name="i386"> Modified: trunk/reactos/ntoskrnl/ps/process.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ps/process.c?rev=… ============================================================================== --- trunk/reactos/ntoskrnl/ps/process.c (original) +++ trunk/reactos/ntoskrnl/ps/process.c Mon Oct 30 17:17:37 2006 @@ -361,7 +361,7 @@ { HANDLE hProcess; PEPROCESS Process, Parent; - PEPORT ExceptionPortObject; + PVOID ExceptionPortObject; PDEBUG_OBJECT DebugObject; PSECTION_OBJECT SectionObject; NTSTATUS Status, AccessStatus; Modified: trunk/reactos/ntoskrnl/ps/query.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ps/query.c?rev=24… ============================================================================== --- trunk/reactos/ntoskrnl/ps/query.c (original) +++ trunk/reactos/ntoskrnl/ps/query.c Mon Oct 30 17:17:37 2006 @@ -486,7 +486,7 @@ HANDLE PortHandle = NULL; HANDLE TokenHandle = NULL; PROCESS_SESSION_INFORMATION SessionInfo = {0}; - PEPORT ExceptionPort; + PVOID ExceptionPort; PAGED_CODE(); /* Verify Information Class validity */

18 years, 1 month

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs October 2006