Export (0) Print
Expand All
This topic has not yet been rated - Rate this topic

TransactNamedPipe function

Combines the functions that write a message to and read a message from the specified named pipe into a single network operation.

Syntax


BOOL WINAPI TransactNamedPipe(
  _In_         HANDLE hNamedPipe,
  _In_         LPVOID lpInBuffer,
  _In_         DWORD nInBufferSize,
  _Out_        LPVOID lpOutBuffer,
  _In_         DWORD nOutBufferSize,
  _Out_        LPDWORD lpBytesRead,
  _Inout_opt_  LPOVERLAPPED lpOverlapped
);

Parameters

hNamedPipe [in]

A handle to the named pipe returned by the CreateNamedPipe or CreateFile function.

This parameter can also be a handle to an anonymous pipe, as returned by the CreatePipe function.

lpInBuffer [in]

A pointer to the buffer containing the data to be written to the pipe.

nInBufferSize [in]

The size of the input buffer, in bytes.

lpOutBuffer [out]

A pointer to the buffer that receives the data read from the pipe.

nOutBufferSize [in]

The size of the output buffer, in bytes.

lpBytesRead [out]

A pointer to the variable that receives the number of bytes read from the pipe.

If lpOverlapped is NULL, lpBytesRead cannot be NULL.

If lpOverlapped is not NULL, lpBytesRead can be NULL. If this is an overlapped read operation, you can get the number of bytes read by calling GetOverlappedResult. If hNamedPipe is associated with an I/O completion port, you can get the number of bytes read by calling GetQueuedCompletionStatus.

lpOverlapped [in, out, optional]

A pointer to an OVERLAPPED structure. This structure is required if hNamedPipe was opened with FILE_FLAG_OVERLAPPED.

If hNamedPipe was opened with FILE_FLAG_OVERLAPPED, the lpOverlapped parameter must not be NULL. It must point to a valid OVERLAPPED structure. If hNamedPipe was created with FILE_FLAG_OVERLAPPED and lpOverlapped is NULL, the function can incorrectly report that the operation is complete.

If hNamedPipe was opened with FILE_FLAG_OVERLAPPED and lpOverlapped is not NULL, TransactNamedPipe is executed as an overlapped operation. The OVERLAPPED structure should contain a manual-reset event object (which can be created by using the CreateEvent function). If the operation cannot be completed immediately, TransactNamedPipe returns FALSE and GetLastError returns ERROR_IO_PENDING. In this situation, the event object is set to the nonsignaled state before TransactNamedPipe returns, and it is set to the signaled state when the transaction has finished. Also, you can be notified when an overlapped operation completes by using the GetQueuedCompletionStatus or GetQueuedCompletionStatusEx functions. In this case, you do not need to assign the manual-reset event in the OVERLAPPED structure, and the completion happens against hNamedPipe in the same way as an asynchronous read or write operation. For more information about overlapped operations, see Pipes.

If hNamedPipe was not opened with FILE_FLAG_OVERLAPPED, TransactNamedPipe does not return until the operation is complete.

Return value

If the function succeeds, the return value is nonzero.

If the function fails, the return value is zero. To get extended error information, call GetLastError.

If the message to be read is longer than the buffer specified by the nOutBufferSize parameter, TransactNamedPipe returns FALSE and the GetLastError function returns ERROR_MORE_DATA. The remainder of the message can be read by a subsequent call to ReadFile, ReadFileEx, or PeekNamedPipe.

Remarks

TransactNamedPipe fails if the server did not create the pipe as a message-type pipe or if the pipe handle is not in message-read mode. For example, if a client is running on the same machine as the server and uses the \\.\pipe\pipename format to open the pipe, the pipe is opened in byte mode by the named pipe file system (NPFS). If the client uses the form \\server\pipe\pipename, the redirector opens the pipe in message mode. A byte mode pipe handle can be changed to message-read mode with the SetNamedPipeHandleState function.

The function cannot be completed successfully until data is written into the buffer specified by the lpOutBuffer parameter. The lpOverlapped parameter is available to enable the calling thread to perform other tasks while the operation is executing in the background.

The maximum guaranteed size of a named pipe transaction is 64 kilobytes. In some limited cases, transactions beyond 64 kilobytes are possible, depending on OS versions participating in the transaction and dynamic network conditions. However, there is no guarantee that transactions above 64 kilobytes will succeed. Therefore it's recommended that named pipe transactions be limited to 64 kilobytes of data.

Examples

For an example, see Transactions on Named Pipes.

Requirements

Minimum supported client

Windows 2000 Professional [desktop apps only]

Minimum supported server

Windows 2000 Server [desktop apps only]

Header

Winbase.h (include Windows.h)

Library

Kernel32.lib

DLL

Kernel32.dll

See also

CreateEvent
CreateFile
CreateNamedPipe
GetOverlappedResult
GetQueuedCompletionStatus
PeekNamedPipe
Pipe Functions
Pipes Overview
ReadFile
ReadFileEx
SetNamedPipeHandleState
OVERLAPPED

 

 

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.