[KERNEL32] Fix MSVC build
[reactos.git] / dll / win32 / kernel32 / client / file / npipe.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32 Kernel Library
4 * FILE: dll/win32/kernel32/client/file/npipe.c
5 * PURPOSE: Named Pipe Functions
6 * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
7 * Ariadne ( ariadne@xs4all.nl)
8 */
9
10 /* INCLUDES *******************************************************************/
11
12 #include <k32.h>
13 #define NDEBUG
14 #include <debug.h>
15 DEBUG_CHANNEL(kernel32file);
16
17 /* GLOBALS ********************************************************************/
18
19 LONG ProcessPipeId;
20
21 /* FUNCTIONS ******************************************************************/
22
23 /*
24 * @implemented
25 */
26 static
27 BOOL
28 NpGetUserNamep(HANDLE hNamedPipe,
29 LPWSTR lpUserName,
30 DWORD nMaxUserNameSize)
31 {
32 BOOL Ret;
33 HANDLE hToken;
34 HMODULE hAdvapi;
35 NTSTATUS Status;
36 BOOL (WINAPI *pRevertToSelf)(void);
37 BOOL (WINAPI *pGetUserNameW)(LPWSTR lpBuffer, LPDWORD lpnSize);
38 BOOL (WINAPI *pImpersonateNamedPipeClient)(HANDLE hNamedPipe);
39
40 /* Open advapi, we'll funcs from it */
41 hAdvapi = LoadLibraryW(L"advapi32.dll");
42 if (hAdvapi == NULL)
43 {
44 return FALSE;
45 }
46
47 /* Import the three required functions */
48 pRevertToSelf = (BOOL (WINAPI *)(void))GetProcAddress(hAdvapi, "RevertToSelf");
49 pGetUserNameW = (BOOL (WINAPI *)(LPWSTR, LPDWORD))GetProcAddress(hAdvapi, "GetUserNameW");
50 pImpersonateNamedPipeClient = (BOOL (WINAPI *)(HANDLE))GetProcAddress(hAdvapi, "ImpersonateNamedPipeClient");
51 /* If any couldn't be found, fail */
52 if (pRevertToSelf == NULL || pGetUserNameW == NULL || pImpersonateNamedPipeClient == NULL)
53 {
54 FreeLibrary(hAdvapi);
55 return FALSE;
56 }
57
58 /* Now, open the thread token for impersonation */
59 Status = NtOpenThreadToken(NtCurrentThread(), TOKEN_IMPERSONATE, TRUE, &hToken);
60 /* Try to impersonate the pipe client */
61 if (pImpersonateNamedPipeClient(hNamedPipe))
62 {
63 DWORD lpnSize;
64
65 /* It worked, get the user name */
66 lpnSize = nMaxUserNameSize;
67 Ret = pGetUserNameW(lpUserName, &lpnSize);
68 /* Failed to get the thread token? Revert to self */
69 if (!NT_SUCCESS(Status))
70 {
71 pRevertToSelf();
72
73 FreeLibrary(hAdvapi);
74 return Ret;
75 }
76
77 /* Restore the thread token */
78 Status = NtSetInformationThread(NtCurrentThread(), ThreadImpersonationToken,
79 &hToken, sizeof(HANDLE));
80 /* We cannot fail closing the thread token! */
81 if (!CloseHandle(hToken))
82 {
83 ASSERT(FALSE);
84 }
85
86 /* Set last error if it failed */
87 if (!NT_SUCCESS(Status))
88 {
89 BaseSetLastNTError(Status);
90 }
91 }
92 else
93 {
94 /* If opening the thread token succeed, close it */
95 if (NT_SUCCESS(Status))
96 {
97 /* We cannot fail closing it! */
98 if (!CloseHandle(hToken))
99 {
100 ASSERT(FALSE);
101 }
102 }
103
104 Ret = FALSE;
105 }
106
107 FreeLibrary(hAdvapi);
108 return Ret;
109 }
110
111
112 /*
113 * @implemented
114 */
115 BOOL
116 WINAPI
117 CreatePipe(PHANDLE hReadPipe,
118 PHANDLE hWritePipe,
119 LPSECURITY_ATTRIBUTES lpPipeAttributes,
120 DWORD nSize)
121 {
122 WCHAR Buffer[64];
123 UNICODE_STRING PipeName;
124 OBJECT_ATTRIBUTES ObjectAttributes;
125 IO_STATUS_BLOCK StatusBlock;
126 LARGE_INTEGER DefaultTimeout;
127 NTSTATUS Status;
128 HANDLE ReadPipeHandle;
129 HANDLE WritePipeHandle;
130 LONG PipeId;
131 ULONG Attributes;
132 PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
133
134 /* Set the timeout to 120 seconds */
135 DefaultTimeout.QuadPart = -1200000000;
136
137 /* Use default buffer size if desired */
138 if (!nSize) nSize = 0x1000;
139
140 /* Increase the Pipe ID */
141 PipeId = InterlockedIncrement(&ProcessPipeId);
142
143 /* Create the pipe name */
144 swprintf(Buffer,
145 L"\\Device\\NamedPipe\\Win32Pipes.%08x.%08x",
146 NtCurrentTeb()->ClientId.UniqueProcess,
147 PipeId);
148 RtlInitUnicodeString(&PipeName, Buffer);
149
150 /* Always use case insensitive */
151 Attributes = OBJ_CASE_INSENSITIVE;
152
153 /* Check if we got attributes */
154 if (lpPipeAttributes)
155 {
156 /* Use the attributes' SD instead */
157 SecurityDescriptor = lpPipeAttributes->lpSecurityDescriptor;
158
159 /* Set OBJ_INHERIT if requested */
160 if (lpPipeAttributes->bInheritHandle) Attributes |= OBJ_INHERIT;
161 }
162
163 /* Initialize the attributes */
164 InitializeObjectAttributes(&ObjectAttributes,
165 &PipeName,
166 Attributes,
167 NULL,
168 SecurityDescriptor);
169
170 /* Create the named pipe */
171 Status = NtCreateNamedPipeFile(&ReadPipeHandle,
172 GENERIC_READ |FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
173 &ObjectAttributes,
174 &StatusBlock,
175 FILE_SHARE_READ | FILE_SHARE_WRITE,
176 FILE_CREATE,
177 FILE_SYNCHRONOUS_IO_NONALERT,
178 FILE_PIPE_BYTE_STREAM_TYPE,
179 FILE_PIPE_BYTE_STREAM_MODE,
180 FILE_PIPE_QUEUE_OPERATION,
181 1,
182 nSize,
183 nSize,
184 &DefaultTimeout);
185 if (!NT_SUCCESS(Status))
186 {
187 /* Convert error and fail */
188 WARN("Status: %lx\n", Status);
189 BaseSetLastNTError(Status);
190 return FALSE;
191 }
192
193 /* Now try opening it for write access */
194 Status = NtOpenFile(&WritePipeHandle,
195 FILE_GENERIC_WRITE,
196 &ObjectAttributes,
197 &StatusBlock,
198 FILE_SHARE_READ,
199 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
200 if (!NT_SUCCESS(Status))
201 {
202 /* Convert error and fail */
203 WARN("Status: %lx\n", Status);
204 NtClose(ReadPipeHandle);
205 BaseSetLastNTError(Status);
206 return FALSE;
207 }
208
209 /* Return both handles */
210 *hReadPipe = ReadPipeHandle;
211 *hWritePipe = WritePipeHandle;
212 return TRUE;
213 }
214
215 /*
216 * @implemented
217 */
218 HANDLE
219 WINAPI
220 CreateNamedPipeA(LPCSTR lpName,
221 DWORD dwOpenMode,
222 DWORD dwPipeMode,
223 DWORD nMaxInstances,
224 DWORD nOutBufferSize,
225 DWORD nInBufferSize,
226 DWORD nDefaultTimeOut,
227 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
228 {
229 /* Call the W(ide) function */
230 ConvertWin32AnsiChangeApiToUnicodeApi(CreateNamedPipe,
231 lpName,
232 dwOpenMode,
233 dwPipeMode,
234 nMaxInstances,
235 nOutBufferSize,
236 nInBufferSize,
237 nDefaultTimeOut,
238 lpSecurityAttributes);
239 }
240
241 /*
242 * @implemented
243 */
244 HANDLE
245 WINAPI
246 CreateNamedPipeW(LPCWSTR lpName,
247 DWORD dwOpenMode,
248 DWORD dwPipeMode,
249 DWORD nMaxInstances,
250 DWORD nOutBufferSize,
251 DWORD nInBufferSize,
252 DWORD nDefaultTimeOut,
253 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
254 {
255 UNICODE_STRING NamedPipeName;
256 BOOL Result;
257 NTSTATUS Status;
258 OBJECT_ATTRIBUTES ObjectAttributes;
259 HANDLE PipeHandle;
260 ACCESS_MASK DesiredAccess;
261 ULONG CreateOptions = 0;
262 ULONG WriteModeMessage;
263 ULONG ReadModeMessage;
264 ULONG NonBlocking;
265 IO_STATUS_BLOCK Iosb;
266 ULONG ShareAccess = 0, Attributes;
267 LARGE_INTEGER DefaultTimeOut;
268 PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
269
270 /* Check for valid instances */
271 if (nMaxInstances == 0 || nMaxInstances > PIPE_UNLIMITED_INSTANCES)
272 {
273 /* Fail */
274 SetLastError(ERROR_INVALID_PARAMETER);
275 return INVALID_HANDLE_VALUE;
276 }
277
278 /* Convert to NT syntax */
279 if (nMaxInstances == PIPE_UNLIMITED_INSTANCES)
280 nMaxInstances = -1;
281
282 /* Convert the name */
283 Result = RtlDosPathNameToNtPathName_U(lpName,
284 &NamedPipeName,
285 NULL,
286 NULL);
287 if (!Result)
288 {
289 /* Conversion failed */
290 SetLastError(ERROR_PATH_NOT_FOUND);
291 return INVALID_HANDLE_VALUE;
292 }
293
294 TRACE("Pipe name: %wZ\n", &NamedPipeName);
295 TRACE("Pipe name: %S\n", NamedPipeName.Buffer);
296
297 /* Always case insensitive, check if we got extra attributes */
298 Attributes = OBJ_CASE_INSENSITIVE;
299 if(lpSecurityAttributes)
300 {
301 /* We did; get the security descriptor */
302 SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor;
303
304 /* And check if this is pipe's handle will beinheritable */
305 if (lpSecurityAttributes->bInheritHandle)
306 Attributes |= OBJ_INHERIT;
307 }
308
309 /* Now we can initialize the object attributes */
310 InitializeObjectAttributes(&ObjectAttributes,
311 &NamedPipeName,
312 Attributes,
313 NULL,
314 SecurityDescriptor);
315
316 /* Setup the default Desired Access */
317 DesiredAccess = SYNCHRONIZE | (dwOpenMode & (WRITE_DAC |
318 WRITE_OWNER |
319 ACCESS_SYSTEM_SECURITY));
320
321 /* Convert to NT Create Flags */
322 if (dwOpenMode & FILE_FLAG_WRITE_THROUGH)
323 {
324 CreateOptions |= FILE_WRITE_THROUGH;
325 }
326
327 if (!(dwOpenMode & FILE_FLAG_OVERLAPPED))
328 {
329 CreateOptions |= FILE_SYNCHRONOUS_IO_NONALERT;
330 }
331
332 /* Handle all open modes */
333 if (dwOpenMode & PIPE_ACCESS_OUTBOUND)
334 {
335 ShareAccess |= FILE_SHARE_READ;
336 DesiredAccess |= GENERIC_WRITE;
337 }
338
339 if (dwOpenMode & PIPE_ACCESS_INBOUND)
340 {
341 ShareAccess |= FILE_SHARE_WRITE;
342 DesiredAccess |= GENERIC_READ;
343 }
344
345 /* Handle the type flags */
346 if (dwPipeMode & PIPE_TYPE_MESSAGE)
347 {
348 WriteModeMessage = FILE_PIPE_MESSAGE_TYPE;
349 }
350 else
351 {
352 WriteModeMessage = FILE_PIPE_BYTE_STREAM_TYPE;
353 }
354
355 /* Handle the mode flags */
356 if (dwPipeMode & PIPE_READMODE_MESSAGE)
357 {
358 ReadModeMessage = FILE_PIPE_MESSAGE_MODE;
359 }
360 else
361 {
362 ReadModeMessage = FILE_PIPE_BYTE_STREAM_MODE;
363 }
364
365 /* Handle the blocking mode */
366 if (dwPipeMode & PIPE_NOWAIT)
367 {
368 NonBlocking = FILE_PIPE_COMPLETE_OPERATION;
369 }
370 else
371 {
372 NonBlocking = FILE_PIPE_QUEUE_OPERATION;
373 }
374
375 /* Check if we have a timeout */
376 if (nDefaultTimeOut)
377 {
378 /* Convert the time to NT format */
379 DefaultTimeOut.QuadPart = nDefaultTimeOut * -10000LL;
380 }
381 else
382 {
383 /* Use default timeout of 50 ms */
384 DefaultTimeOut.QuadPart = -500000;
385 }
386
387 /* Now create the pipe */
388 Status = NtCreateNamedPipeFile(&PipeHandle,
389 DesiredAccess,
390 &ObjectAttributes,
391 &Iosb,
392 ShareAccess,
393 FILE_OPEN_IF,
394 CreateOptions,
395 WriteModeMessage,
396 ReadModeMessage,
397 NonBlocking,
398 nMaxInstances,
399 nInBufferSize,
400 nOutBufferSize,
401 &DefaultTimeOut);
402
403 /* Normalize special error codes */
404 if ((Status == STATUS_INVALID_DEVICE_REQUEST) ||
405 (Status == STATUS_NOT_SUPPORTED))
406 {
407 Status = STATUS_OBJECT_NAME_INVALID;
408 }
409
410 /* Free the name */
411 RtlFreeHeap(RtlGetProcessHeap(),
412 0,
413 NamedPipeName.Buffer);
414
415 /* Check status */
416 if (!NT_SUCCESS(Status))
417 {
418 /* Failed to create it */
419 WARN("NtCreateNamedPipe failed (Status %x)!\n", Status);
420 BaseSetLastNTError (Status);
421 return INVALID_HANDLE_VALUE;
422 }
423
424 /* Return the handle */
425 return PipeHandle;
426 }
427
428 /*
429 * @implemented
430 */
431 BOOL
432 WINAPI
433 WaitNamedPipeA(LPCSTR lpNamedPipeName,
434 DWORD nTimeOut)
435 {
436 BOOL r = FALSE;
437 UNICODE_STRING NameU;
438
439 /* Convert the name to Unicode */
440 if (Basep8BitStringToDynamicUnicodeString(&NameU, lpNamedPipeName))
441 {
442 /* Call the Unicode API */
443 r = WaitNamedPipeW(NameU.Buffer, nTimeOut);
444
445 /* Free the Unicode string */
446 RtlFreeUnicodeString(&NameU);
447 }
448
449 /* Return result */
450 return r;
451 }
452
453 /*
454 * @implemented
455 */
456 BOOL
457 WINAPI
458 WaitNamedPipeW(LPCWSTR lpNamedPipeName,
459 DWORD nTimeOut)
460 {
461 UNICODE_STRING NamedPipeName, NewName, DevicePath, PipePrefix;
462 ULONG NameLength;
463 ULONG i;
464 PWCHAR p;
465 ULONG Type;
466 OBJECT_ATTRIBUTES ObjectAttributes;
467 NTSTATUS Status;
468 HANDLE FileHandle;
469 IO_STATUS_BLOCK IoStatusBlock;
470 ULONG WaitPipeInfoSize;
471 PFILE_PIPE_WAIT_FOR_BUFFER WaitPipeInfo;
472
473 /* Start by making a unicode string of the name */
474 TRACE("Sent path: %S\n", lpNamedPipeName);
475 if (!RtlCreateUnicodeString(&NamedPipeName, lpNamedPipeName))
476 {
477 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
478 return FALSE;
479 }
480 NameLength = NamedPipeName.Length / sizeof(WCHAR);
481
482 /* All slashes must become backslashes */
483 for (i = 0; i < NameLength; i++)
484 {
485 /* Check and convert */
486 if (NamedPipeName.Buffer[i] == L'/') NamedPipeName.Buffer[i] = L'\\';
487 }
488
489 /* Find the path type of the name we were given */
490 NewName = NamedPipeName;
491 Type = RtlDetermineDosPathNameType_U(lpNamedPipeName);
492
493 /* Check if this was a device path, ie : "\\.\pipe\name" */
494 if (Type == RtlPathTypeLocalDevice)
495 {
496 /* Make sure it's a valid prefix */
497 RtlInitUnicodeString(&PipePrefix, L"\\\\.\\pipe\\");
498 if (!RtlPrefixUnicodeString(&PipePrefix, &NewName, TRUE))
499 {
500 /* The name is invalid */
501 WARN("Invalid name!\n");
502 RtlFreeUnicodeString(&NamedPipeName);
503 BaseSetLastNTError(STATUS_OBJECT_PATH_SYNTAX_BAD);
504 return FALSE;
505 }
506
507 /* Move past it */
508 NewName.Buffer += PipePrefix.Length / sizeof(WCHAR);
509 NewName.Length -= PipePrefix.Length;
510 NewName.MaximumLength -= PipePrefix.Length;
511
512 /* Initialize the Dos Devices name */
513 TRACE("NewName: %wZ\n", &NewName);
514 RtlInitUnicodeString(&DevicePath, L"\\DosDevices\\pipe\\");
515 }
516 else if (Type == RtlPathTypeUncAbsolute)
517 {
518 /* The path is \\server\\pipe\name; find the pipename itself */
519 p = &NewName.Buffer[2];
520
521 /* First loop to get past the server name */
522 do
523 {
524 /* Check if this is a backslash */
525 if (*p == L'\\') break;
526
527 /* Check next */
528 p++;
529 } while (*p);
530
531 /* Now make sure the full name contains "pipe\" */
532 if ((*p) && !(_wcsnicmp(p + 1, L"pipe\\", sizeof("pipe\\") - sizeof(ANSI_NULL))))
533 {
534 /* Get to the pipe name itself now */
535 p += sizeof("pipe\\") - sizeof(ANSI_NULL);
536 }
537 else
538 {
539 /* The name is invalid */
540 WARN("Invalid name!\n");
541 RtlFreeUnicodeString(&NamedPipeName);
542 BaseSetLastNTError(STATUS_OBJECT_PATH_SYNTAX_BAD);
543 return FALSE;
544 }
545
546 /* FIXME: Open \DosDevices\Unc\Server\Pipe\Name */
547 }
548 else
549 {
550 WARN("Invalid path type\n");
551 RtlFreeUnicodeString(&NamedPipeName);
552 BaseSetLastNTError(STATUS_OBJECT_PATH_SYNTAX_BAD);
553 return FALSE;
554 }
555
556 /* Now calculate the total length of the structure and allocate it */
557 WaitPipeInfoSize = FIELD_OFFSET(FILE_PIPE_WAIT_FOR_BUFFER, Name[0]) +
558 NewName.Length;
559 WaitPipeInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, WaitPipeInfoSize);
560 if (WaitPipeInfo == NULL)
561 {
562 RtlFreeUnicodeString(&NamedPipeName);
563 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
564 return FALSE;
565 }
566
567 /* Initialize the object attributes */
568 TRACE("Opening: %wZ\n", &DevicePath);
569 InitializeObjectAttributes(&ObjectAttributes,
570 &DevicePath,
571 OBJ_CASE_INSENSITIVE,
572 NULL,
573 NULL);
574
575 /* Open the path */
576 Status = NtOpenFile(&FileHandle,
577 FILE_READ_ATTRIBUTES | SYNCHRONIZE,
578 &ObjectAttributes,
579 &IoStatusBlock,
580 FILE_SHARE_READ | FILE_SHARE_WRITE,
581 FILE_SYNCHRONOUS_IO_NONALERT);
582 if (!NT_SUCCESS(Status))
583 {
584 /* Fail; couldn't open */
585 WARN("Status: %lx\n", Status);
586 RtlFreeHeap(RtlGetProcessHeap(), 0, WaitPipeInfo);
587 RtlFreeUnicodeString(&NamedPipeName);
588 BaseSetLastNTError(Status);
589 return FALSE;
590 }
591
592 /* Check what timeout we got */
593 if (nTimeOut == NMPWAIT_USE_DEFAULT_WAIT)
594 {
595 /* Don't use a timeout */
596 WaitPipeInfo->TimeoutSpecified = FALSE;
597 }
598 else
599 {
600 /* Check if we should wait forever */
601 if (nTimeOut == NMPWAIT_WAIT_FOREVER)
602 {
603 /* Set the max */
604 WaitPipeInfo->Timeout.LowPart = 0;
605 WaitPipeInfo->Timeout.HighPart = 0x80000000;
606 }
607 else
608 {
609 /* Convert to NT format */
610 WaitPipeInfo->Timeout.QuadPart = nTimeOut * -10000LL;
611 }
612
613 /* In both cases, we do have a timeout */
614 WaitPipeInfo->TimeoutSpecified = TRUE;
615 }
616
617 /* Set the length and copy the name */
618 WaitPipeInfo->NameLength = NewName.Length;
619 RtlCopyMemory(WaitPipeInfo->Name, NewName.Buffer, NewName.Length);
620
621 /* Get rid of the full name */
622 RtlFreeUnicodeString(&NamedPipeName);
623
624 /* Let NPFS know of our request */
625 Status = NtFsControlFile(FileHandle,
626 NULL,
627 NULL,
628 NULL,
629 &IoStatusBlock,
630 FSCTL_PIPE_WAIT,
631 WaitPipeInfo,
632 WaitPipeInfoSize,
633 NULL,
634 0);
635
636 /* Free our pipe info data and close the handle */
637 RtlFreeHeap(RtlGetProcessHeap(), 0, WaitPipeInfo);
638 NtClose(FileHandle);
639
640 /* Check the status */
641 if (!NT_SUCCESS(Status))
642 {
643 /* Failure to wait on the pipe */
644 WARN("Status: %lx\n", Status);
645 BaseSetLastNTError(Status);
646 return FALSE;
647 }
648
649 /* Success */
650 return TRUE;
651 }
652
653 /*
654 * @implemented
655 */
656 BOOL
657 WINAPI
658 ConnectNamedPipe(IN HANDLE hNamedPipe,
659 IN LPOVERLAPPED lpOverlapped)
660 {
661 NTSTATUS Status;
662
663 if (lpOverlapped != NULL)
664 {
665 PVOID ApcContext;
666
667 lpOverlapped->Internal = STATUS_PENDING;
668 ApcContext = (((ULONG_PTR)lpOverlapped->hEvent & 0x1) ? NULL : lpOverlapped);
669
670 Status = NtFsControlFile(hNamedPipe,
671 lpOverlapped->hEvent,
672 NULL,
673 ApcContext,
674 (PIO_STATUS_BLOCK)lpOverlapped,
675 FSCTL_PIPE_LISTEN,
676 NULL,
677 0,
678 NULL,
679 0);
680
681 /* return FALSE in case of failure and pending operations! */
682 if (!NT_SUCCESS(Status) || Status == STATUS_PENDING)
683 {
684 BaseSetLastNTError(Status);
685 return FALSE;
686 }
687 }
688 else
689 {
690 IO_STATUS_BLOCK Iosb;
691
692 Status = NtFsControlFile(hNamedPipe,
693 NULL,
694 NULL,
695 NULL,
696 &Iosb,
697 FSCTL_PIPE_LISTEN,
698 NULL,
699 0,
700 NULL,
701 0);
702
703 /* wait in case operation is pending */
704 if (Status == STATUS_PENDING)
705 {
706 Status = NtWaitForSingleObject(hNamedPipe,
707 FALSE,
708 NULL);
709 if (NT_SUCCESS(Status))
710 {
711 Status = Iosb.Status;
712 }
713 }
714
715 if (!NT_SUCCESS(Status))
716 {
717 BaseSetLastNTError(Status);
718 return FALSE;
719 }
720 }
721
722 return TRUE;
723 }
724
725
726 /*
727 * @implemented
728 */
729 BOOL
730 WINAPI
731 SetNamedPipeHandleState(HANDLE hNamedPipe,
732 LPDWORD lpMode,
733 LPDWORD lpMaxCollectionCount,
734 LPDWORD lpCollectDataTimeout)
735 {
736 IO_STATUS_BLOCK Iosb;
737 NTSTATUS Status;
738
739 /* Check if the Mode is being changed */
740 if (lpMode)
741 {
742 FILE_PIPE_INFORMATION Settings;
743
744 /* Set the Completion Mode */
745 Settings.CompletionMode = (*lpMode & PIPE_NOWAIT) ?
746 FILE_PIPE_COMPLETE_OPERATION : FILE_PIPE_QUEUE_OPERATION;
747
748 /* Set the Read Mode */
749 Settings.ReadMode = (*lpMode & PIPE_READMODE_MESSAGE) ?
750 FILE_PIPE_MESSAGE_MODE: FILE_PIPE_BYTE_STREAM_MODE;
751
752 /* Send the changes to the Driver */
753 Status = NtSetInformationFile(hNamedPipe,
754 &Iosb,
755 &Settings,
756 sizeof(FILE_PIPE_INFORMATION),
757 FilePipeInformation);
758 if (!NT_SUCCESS(Status))
759 {
760 BaseSetLastNTError(Status);
761 return FALSE;
762 }
763 }
764
765 /* Check if the Collection count or Timeout are being changed */
766 if (lpMaxCollectionCount || lpCollectDataTimeout)
767 {
768 FILE_PIPE_REMOTE_INFORMATION RemoteSettings;
769
770 /* Setting one without the other would delete it, so we read old one */
771 if (!lpMaxCollectionCount || !lpCollectDataTimeout)
772 {
773 Status = NtQueryInformationFile(hNamedPipe,
774 &Iosb,
775 &RemoteSettings,
776 sizeof(FILE_PIPE_REMOTE_INFORMATION),
777 FilePipeRemoteInformation);
778 if (!NT_SUCCESS(Status))
779 {
780 BaseSetLastNTError(Status);
781 return FALSE;
782 }
783 }
784
785 /* Now set the new settings */
786 RemoteSettings.MaximumCollectionCount = (lpMaxCollectionCount) ?
787 *lpMaxCollectionCount :
788 RemoteSettings.MaximumCollectionCount;
789 if (lpCollectDataTimeout)
790 {
791 /* Convert it to Quad */
792 RemoteSettings.CollectDataTime.QuadPart = *lpCollectDataTimeout * -10000LL;
793 }
794
795 /* Tell the driver to change them */
796 Status = NtSetInformationFile(hNamedPipe,
797 &Iosb,
798 &RemoteSettings,
799 sizeof(FILE_PIPE_REMOTE_INFORMATION),
800 FilePipeRemoteInformation);
801 if (!NT_SUCCESS(Status))
802 {
803 BaseSetLastNTError(Status);
804 return FALSE;
805 }
806 }
807
808 return TRUE;
809 }
810
811
812 /*
813 * @implemented
814 */
815 BOOL
816 WINAPI
817 CallNamedPipeA(LPCSTR lpNamedPipeName,
818 LPVOID lpInBuffer,
819 DWORD nInBufferSize,
820 LPVOID lpOutBuffer,
821 DWORD nOutBufferSize,
822 LPDWORD lpBytesRead,
823 DWORD nTimeOut)
824 {
825 PUNICODE_STRING PipeName = &NtCurrentTeb()->StaticUnicodeString;
826 ANSI_STRING AnsiPipe;
827
828 /* Initialize the string as ANSI_STRING and convert to Unicode */
829 RtlInitAnsiString(&AnsiPipe, (LPSTR)lpNamedPipeName);
830 RtlAnsiStringToUnicodeString(PipeName, &AnsiPipe, FALSE);
831
832 /* Call the Unicode function */
833 return CallNamedPipeW(PipeName->Buffer,
834 lpInBuffer,
835 nInBufferSize,
836 lpOutBuffer,
837 nOutBufferSize,
838 lpBytesRead,
839 nTimeOut);
840 }
841
842
843 /*
844 * @implemented
845 */
846 BOOL
847 WINAPI
848 CallNamedPipeW(LPCWSTR lpNamedPipeName,
849 LPVOID lpInBuffer,
850 DWORD nInBufferSize,
851 LPVOID lpOutBuffer,
852 DWORD nOutBufferSize,
853 LPDWORD lpBytesRead,
854 DWORD nTimeOut)
855 {
856 HANDLE hPipe;
857 BOOL bRetry = TRUE;
858 BOOL bError;
859 DWORD dwPipeMode;
860
861 while (TRUE)
862 {
863 /* Try creating it */
864 hPipe = CreateFileW(lpNamedPipeName,
865 GENERIC_READ | GENERIC_WRITE,
866 FILE_SHARE_READ | FILE_SHARE_WRITE,
867 NULL,
868 OPEN_EXISTING,
869 FILE_ATTRIBUTE_NORMAL,
870 NULL);
871
872 /* Success, break out */
873 if (hPipe != INVALID_HANDLE_VALUE)
874 break;
875
876 /* Already tried twice, give up */
877 if (bRetry == FALSE)
878 return FALSE;
879
880 /* Wait on it */
881 WaitNamedPipeW(lpNamedPipeName, nTimeOut);
882
883 /* Get ready to try again */
884 bRetry = FALSE;
885 }
886
887 /* Set the pipe mode */
888 dwPipeMode = PIPE_READMODE_MESSAGE | PIPE_WAIT;
889 bError = SetNamedPipeHandleState(hPipe, &dwPipeMode, NULL, NULL);
890 if (!bError)
891 {
892 /* Couldn't change state, fail */
893 CloseHandle(hPipe);
894 return FALSE;
895 }
896
897 /* Do the transact */
898 bError = TransactNamedPipe(hPipe,
899 lpInBuffer,
900 nInBufferSize,
901 lpOutBuffer,
902 nOutBufferSize,
903 lpBytesRead,
904 NULL);
905
906 /* Close the handle */
907 CloseHandle(hPipe);
908
909 return bError;
910 }
911
912
913 /*
914 * @implemented
915 */
916 BOOL
917 WINAPI
918 DisconnectNamedPipe(HANDLE hNamedPipe)
919 {
920 IO_STATUS_BLOCK Iosb;
921 NTSTATUS Status;
922
923 /* Send the FSCTL to the driver */
924 Status = NtFsControlFile(hNamedPipe,
925 NULL,
926 NULL,
927 NULL,
928 &Iosb,
929 FSCTL_PIPE_DISCONNECT,
930 NULL,
931 0,
932 NULL,
933 0);
934 if (Status == STATUS_PENDING)
935 {
936 /* Wait on NPFS to finish and get updated status */
937 Status = NtWaitForSingleObject(hNamedPipe, FALSE, NULL);
938 if (NT_SUCCESS(Status))
939 Status = Iosb.Status;
940 }
941
942 /* Check for error */
943 if (!NT_SUCCESS(Status))
944 {
945 /* Fail */
946 BaseSetLastNTError(Status);
947 return FALSE;
948 }
949
950 return TRUE;
951 }
952
953
954 /*
955 * @unimplemented
956 */
957 BOOL
958 WINAPI
959 GetNamedPipeHandleStateW(HANDLE hNamedPipe,
960 LPDWORD lpState,
961 LPDWORD lpCurInstances,
962 LPDWORD lpMaxCollectionCount,
963 LPDWORD lpCollectDataTimeout,
964 LPWSTR lpUserName,
965 DWORD nMaxUserNameSize)
966 {
967 IO_STATUS_BLOCK StatusBlock;
968 NTSTATUS Status;
969
970 if (lpState != NULL)
971 {
972 FILE_PIPE_INFORMATION PipeInfo;
973
974 Status = NtQueryInformationFile(hNamedPipe,
975 &StatusBlock,
976 &PipeInfo,
977 sizeof(FILE_PIPE_INFORMATION),
978 FilePipeInformation);
979 if (!NT_SUCCESS(Status))
980 {
981 BaseSetLastNTError(Status);
982 return FALSE;
983 }
984
985 *lpState = ((PipeInfo.CompletionMode != FILE_PIPE_QUEUE_OPERATION) ? PIPE_NOWAIT : PIPE_WAIT);
986 *lpState |= ((PipeInfo.ReadMode != FILE_PIPE_BYTE_STREAM_MODE) ? PIPE_READMODE_MESSAGE : PIPE_READMODE_BYTE);
987 }
988
989 if(lpCurInstances != NULL)
990 {
991 FILE_PIPE_LOCAL_INFORMATION LocalInfo;
992
993 Status = NtQueryInformationFile(hNamedPipe,
994 &StatusBlock,
995 &LocalInfo,
996 sizeof(FILE_PIPE_LOCAL_INFORMATION),
997 FilePipeLocalInformation);
998 if (!NT_SUCCESS(Status))
999 {
1000 BaseSetLastNTError(Status);
1001 return FALSE;
1002 }
1003
1004 *lpCurInstances = min(LocalInfo.CurrentInstances, PIPE_UNLIMITED_INSTANCES);
1005 }
1006
1007 if (lpMaxCollectionCount != NULL || lpCollectDataTimeout != NULL)
1008 {
1009 FILE_PIPE_REMOTE_INFORMATION RemoteInfo;
1010
1011 Status = NtQueryInformationFile(hNamedPipe,
1012 &StatusBlock,
1013 &RemoteInfo,
1014 sizeof(FILE_PIPE_REMOTE_INFORMATION),
1015 FilePipeRemoteInformation);
1016 if (!NT_SUCCESS(Status))
1017 {
1018 BaseSetLastNTError(Status);
1019 return FALSE;
1020 }
1021
1022 if (lpMaxCollectionCount != NULL)
1023 {
1024 *lpMaxCollectionCount = RemoteInfo.MaximumCollectionCount;
1025 }
1026
1027 if (lpCollectDataTimeout != NULL)
1028 {
1029 LARGE_INTEGER CollectDataTime;
1030
1031 /* Convert time and return it */
1032 RemoteInfo.CollectDataTime.QuadPart *= -1;
1033 CollectDataTime = RtlExtendedLargeIntegerDivide(RemoteInfo.CollectDataTime, 10000, NULL);
1034 /* In case of overflow, just return MAX - 1 */
1035 if (CollectDataTime.HighPart != 0)
1036 {
1037 *lpCollectDataTimeout = -2;
1038 }
1039 else
1040 {
1041 *lpCollectDataTimeout = CollectDataTime.LowPart;
1042 }
1043 }
1044 }
1045
1046 if (lpUserName != NULL)
1047 {
1048 return NpGetUserNamep(hNamedPipe, lpUserName, nMaxUserNameSize);
1049 }
1050
1051 return TRUE;
1052 }
1053
1054
1055 /*
1056 * @implemented
1057 */
1058 BOOL
1059 WINAPI
1060 GetNamedPipeHandleStateA(HANDLE hNamedPipe,
1061 LPDWORD lpState,
1062 LPDWORD lpCurInstances,
1063 LPDWORD lpMaxCollectionCount,
1064 LPDWORD lpCollectDataTimeout,
1065 LPSTR lpUserName,
1066 DWORD nMaxUserNameSize)
1067 {
1068 UNICODE_STRING UserNameW = { 0, 0, NULL };
1069 ANSI_STRING UserNameA;
1070 BOOL Ret;
1071
1072 if(lpUserName != NULL)
1073 {
1074 UserNameW.MaximumLength = (USHORT)nMaxUserNameSize * sizeof(WCHAR);
1075 UserNameW.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, UserNameW.MaximumLength);
1076 if (UserNameW.Buffer == NULL)
1077 {
1078 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1079 return FALSE;
1080 }
1081
1082 UserNameA.Buffer = lpUserName;
1083 UserNameA.Length = 0;
1084 UserNameA.MaximumLength = (USHORT)nMaxUserNameSize;
1085 }
1086
1087 Ret = GetNamedPipeHandleStateW(hNamedPipe,
1088 lpState,
1089 lpCurInstances,
1090 lpMaxCollectionCount,
1091 lpCollectDataTimeout,
1092 UserNameW.Buffer,
1093 nMaxUserNameSize);
1094 if (Ret && lpUserName != NULL)
1095 {
1096 NTSTATUS Status;
1097
1098 RtlInitUnicodeString(&UserNameW, UserNameW.Buffer);
1099 Status = RtlUnicodeStringToAnsiString(&UserNameA, &UserNameW, FALSE);
1100 if (!NT_SUCCESS(Status))
1101 {
1102 BaseSetLastNTError(Status);
1103 Ret = FALSE;
1104 }
1105 }
1106
1107 if (UserNameW.Buffer != NULL)
1108 {
1109 RtlFreeHeap(RtlGetProcessHeap(), 0, UserNameW.Buffer);
1110 }
1111
1112 return Ret;
1113 }
1114
1115
1116 /*
1117 * @implemented
1118 */
1119 BOOL
1120 WINAPI
1121 GetNamedPipeInfo(HANDLE hNamedPipe,
1122 LPDWORD lpFlags,
1123 LPDWORD lpOutBufferSize,
1124 LPDWORD lpInBufferSize,
1125 LPDWORD lpMaxInstances)
1126 {
1127 FILE_PIPE_LOCAL_INFORMATION PipeLocalInformation;
1128 IO_STATUS_BLOCK StatusBlock;
1129 NTSTATUS Status;
1130
1131 Status = NtQueryInformationFile(hNamedPipe,
1132 &StatusBlock,
1133 &PipeLocalInformation,
1134 sizeof(FILE_PIPE_LOCAL_INFORMATION),
1135 FilePipeLocalInformation);
1136 if (!NT_SUCCESS(Status))
1137 {
1138 BaseSetLastNTError(Status);
1139 return FALSE;
1140 }
1141
1142 if (lpFlags != NULL)
1143 {
1144 *lpFlags = (PipeLocalInformation.NamedPipeEnd == FILE_PIPE_SERVER_END) ? PIPE_SERVER_END : PIPE_CLIENT_END;
1145 *lpFlags |= (PipeLocalInformation.NamedPipeType == 1) ? PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1146 }
1147
1148 if (lpOutBufferSize != NULL)
1149 *lpOutBufferSize = PipeLocalInformation.OutboundQuota;
1150
1151 if (lpInBufferSize != NULL)
1152 *lpInBufferSize = PipeLocalInformation.InboundQuota;
1153
1154 if (lpMaxInstances != NULL)
1155 {
1156 if (PipeLocalInformation.MaximumInstances >= 255)
1157 *lpMaxInstances = PIPE_UNLIMITED_INSTANCES;
1158 else
1159 *lpMaxInstances = PipeLocalInformation.MaximumInstances;
1160 }
1161
1162 return TRUE;
1163 }
1164
1165
1166 /*
1167 * @implemented
1168 */
1169 BOOL
1170 WINAPI
1171 PeekNamedPipe(HANDLE hNamedPipe,
1172 LPVOID lpBuffer,
1173 DWORD nBufferSize,
1174 LPDWORD lpBytesRead,
1175 LPDWORD lpTotalBytesAvail,
1176 LPDWORD lpBytesLeftThisMessage)
1177 {
1178 PFILE_PIPE_PEEK_BUFFER Buffer;
1179 IO_STATUS_BLOCK Iosb;
1180 ULONG BufferSize;
1181 ULONG BytesRead;
1182 NTSTATUS Status;
1183
1184 /* Calculate the buffer space that we'll need and allocate it */
1185 BufferSize = FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[nBufferSize]);
1186 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
1187 if (Buffer == NULL)
1188 {
1189 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1190 return FALSE;
1191 }
1192
1193 /* Tell the driver to seek */
1194 Status = NtFsControlFile(hNamedPipe,
1195 NULL,
1196 NULL,
1197 NULL,
1198 &Iosb,
1199 FSCTL_PIPE_PEEK,
1200 NULL,
1201 0,
1202 Buffer,
1203 BufferSize);
1204 if (Status == STATUS_PENDING)
1205 {
1206 /* Wait for npfs to be done, and update the status */
1207 Status = NtWaitForSingleObject(hNamedPipe, FALSE, NULL);
1208 if (NT_SUCCESS(Status))
1209 Status = Iosb.Status;
1210 }
1211
1212 /* Overflow is success for us */
1213 if (Status == STATUS_BUFFER_OVERFLOW)
1214 Status = STATUS_SUCCESS;
1215
1216 /* If we failed */
1217 if (!NT_SUCCESS(Status))
1218 {
1219 /* Free the buffer and return failure */
1220 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1221 BaseSetLastNTError(Status);
1222 return FALSE;
1223 }
1224
1225 /* Check if caller requested bytes available */
1226 if (lpTotalBytesAvail)
1227 {
1228 /* Return bytes available */
1229 *lpTotalBytesAvail = Buffer->ReadDataAvailable;
1230 }
1231
1232 /* Calculate the bytes returned, minus our structure overhead */
1233 BytesRead = (ULONG)(Iosb.Information -
1234 FIELD_OFFSET(FILE_PIPE_PEEK_BUFFER, Data[0]));
1235 ASSERT(BytesRead <= nBufferSize);
1236
1237 /* Check if caller requested bytes read */
1238 if (lpBytesRead)
1239 {
1240 /* Return the bytes read */
1241 *lpBytesRead = BytesRead;
1242 }
1243
1244 /* Check if caller requested bytes left */
1245 if (lpBytesLeftThisMessage)
1246 {
1247 /* Calculate total minus what we returned and our structure overhead */
1248 *lpBytesLeftThisMessage = Buffer->MessageLength - BytesRead;
1249 }
1250
1251 /* Check if the caller wanted to see the actual data */
1252 if (lpBuffer)
1253 {
1254 /* Give him what he wants */
1255 RtlCopyMemory(lpBuffer,
1256 Buffer->Data,
1257 BytesRead);
1258 }
1259
1260 /* Free the buffer */
1261 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
1262
1263 return TRUE;
1264 }
1265
1266
1267 /*
1268 * @implemented
1269 */
1270 BOOL
1271 WINAPI
1272 TransactNamedPipe(IN HANDLE hNamedPipe,
1273 IN LPVOID lpInBuffer,
1274 IN DWORD nInBufferSize,
1275 OUT LPVOID lpOutBuffer,
1276 IN DWORD nOutBufferSize,
1277 OUT LPDWORD lpBytesRead OPTIONAL,
1278 IN LPOVERLAPPED lpOverlapped OPTIONAL)
1279 {
1280 NTSTATUS Status;
1281
1282 if (lpBytesRead != NULL)
1283 {
1284 *lpBytesRead = 0;
1285 }
1286
1287 if (lpOverlapped != NULL)
1288 {
1289 PVOID ApcContext;
1290
1291 ApcContext = (((ULONG_PTR)lpOverlapped->hEvent & 0x1) ? NULL : lpOverlapped);
1292 lpOverlapped->Internal = STATUS_PENDING;
1293
1294 Status = NtFsControlFile(hNamedPipe,
1295 lpOverlapped->hEvent,
1296 NULL,
1297 ApcContext,
1298 (PIO_STATUS_BLOCK)lpOverlapped,
1299 FSCTL_PIPE_TRANSCEIVE,
1300 lpInBuffer,
1301 nInBufferSize,
1302 lpOutBuffer,
1303 nOutBufferSize);
1304 if (!NT_SUCCESS(Status) || Status == STATUS_PENDING)
1305 {
1306 BaseSetLastNTError(Status);
1307 return FALSE;
1308 }
1309
1310 if (lpBytesRead != NULL)
1311 {
1312 *lpBytesRead = lpOverlapped->InternalHigh;
1313 }
1314 }
1315 else
1316 {
1317 IO_STATUS_BLOCK Iosb;
1318
1319 Status = NtFsControlFile(hNamedPipe,
1320 NULL,
1321 NULL,
1322 NULL,
1323 &Iosb,
1324 FSCTL_PIPE_TRANSCEIVE,
1325 lpInBuffer,
1326 nInBufferSize,
1327 lpOutBuffer,
1328 nOutBufferSize);
1329 if (Status == STATUS_PENDING)
1330 {
1331 Status = NtWaitForSingleObject(hNamedPipe,
1332 FALSE,
1333 NULL);
1334 if (NT_SUCCESS(Status))
1335 Status = Iosb.Status;
1336 }
1337
1338 if (NT_SUCCESS(Status))
1339 {
1340 /* lpNumberOfBytesRead must not be NULL here, in fact Win doesn't
1341 check that case either and crashes (only after the operation
1342 completed) */
1343 *lpBytesRead = Iosb.Information;
1344 }
1345 else
1346 {
1347 BaseSetLastNTError(Status);
1348 return FALSE;
1349 }
1350 }
1351
1352 return TRUE;
1353 }
1354
1355 /* EOF */