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