Transações em pipes nomeados
Uma transação de pipe nomeada é uma comunicação cliente/servidor que combina uma operação de gravação e uma operação de leitura em uma única operação de rede. Uma transação só pode ser usada em um pipe duplex, tipo de mensagem. As transações melhoram o desempenho das comunicações de rede entre um cliente e um servidor remoto. Os processos podem usar as funções TransactNamedPipe e CallNamedPipe para executar transações de pipe nomeadas.
A função TransactNamedPipe é mais comumente usada por um cliente de pipe para gravar uma mensagem de solicitação no servidor de pipe nomeado e ler a mensagem de resposta do servidor. O cliente de pipe deve especificar GENERIC_READ | GENERIC_WRITE acesso ao abrir o identificador de pipe chamando a função CreateFile . Em seguida, o cliente de pipe define o identificador de pipe para o modo de leitura de mensagem chamando a função SetNamedPipeHandleState . Se o buffer de leitura especificado na chamada para TransactNamedPipe não for grande o suficiente para manter a mensagem inteira gravada pelo servidor, a função retornará zero e GetLastError retornará ERROR_MORE_DATA. O cliente pode ler o restante da mensagem chamando a função ReadFile, ReadFileEx ou PeekNamedPipe .
O TransactNamedPipe normalmente é chamado por clientes de pipe, mas também pode ser usado por um servidor de pipe.
O exemplo a seguir mostra um cliente de pipe usando TransactNamedPipe. Esse cliente de pipe pode ser usado com qualquer um dos servidores de pipe listados em Consulte Também.
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#define BUFSIZE 512
int _tmain(int argc, TCHAR *argv[])
{
HANDLE hPipe;
LPTSTR lpszWrite = TEXT("Default message from client");
TCHAR chReadBuf[BUFSIZE];
BOOL fSuccess;
DWORD cbRead, dwMode;
LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
if( argc > 1)
{
lpszWrite = argv[1];
}
// Try to open a named pipe; wait for it, if necessary.
while (1)
{
hPipe = CreateFile(
lpszPipename, // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
0, // default attributes
NULL); // no template file
// Break if the pipe handle is valid.
if (hPipe != INVALID_HANDLE_VALUE)
break;
// Exit if an error other than ERROR_PIPE_BUSY occurs.
if (GetLastError() != ERROR_PIPE_BUSY)
{
printf("Could not open pipe\n");
return 0;
}
// All pipe instances are busy, so wait for 20 seconds.
if (! WaitNamedPipe(lpszPipename, 20000) )
{
printf("Could not open pipe\n");
return 0;
}
}
// The pipe connected; change to message-read mode.
dwMode = PIPE_READMODE_MESSAGE;
fSuccess = SetNamedPipeHandleState(
hPipe, // pipe handle
&dwMode, // new pipe mode
NULL, // don't set maximum bytes
NULL); // don't set maximum time
if (!fSuccess)
{
printf("SetNamedPipeHandleState failed.\n");
return 0;
}
// Send a message to the pipe server and read the response.
fSuccess = TransactNamedPipe(
hPipe, // pipe handle
lpszWrite, // message to server
(lstrlen(lpszWrite)+1)*sizeof(TCHAR), // message length
chReadBuf, // buffer to receive reply
BUFSIZE*sizeof(TCHAR), // size of read buffer
&cbRead, // bytes read
NULL); // not overlapped
if (!fSuccess && (GetLastError() != ERROR_MORE_DATA))
{
printf("TransactNamedPipe failed.\n");
return 0;
}
while(1)
{
_tprintf(TEXT("%s\n"), chReadBuf);
// Break if TransactNamedPipe or ReadFile is successful
if(fSuccess)
break;
// Read from the pipe if there is more data in the message.
fSuccess = ReadFile(
hPipe, // pipe handle
chReadBuf, // buffer to receive reply
BUFSIZE*sizeof(TCHAR), // size of buffer
&cbRead, // number of bytes read
NULL); // not overlapped
// Exit if an error other than ERROR_MORE_DATA occurs.
if( !fSuccess && (GetLastError() != ERROR_MORE_DATA))
break;
else _tprintf( TEXT("%s\n"), chReadBuf);
}
_getch();
CloseHandle(hPipe);
return 0;
}
Um cliente de pipe usa CallNamedPipe para combinar as chamadas de função CreateFile, WaitNamedPipe (se necessário), TransactNamedPipe e CloseHandle em uma única chamada. Como o identificador de pipe é fechado antes que a função retorne, todos os bytes adicionais na mensagem serão perdidos se a mensagem for maior que o tamanho especificado do buffer de leitura. O exemplo a seguir é o exemplo anterior reescrito para usar CallNamedPipe.
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#define BUFSIZE 512
int _tmain(int argc, TCHAR *argv[])
{
LPTSTR lpszWrite = TEXT("Default message from client");
TCHAR chReadBuf[BUFSIZE];
BOOL fSuccess;
DWORD cbRead;
LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
if( argc > 1)
{
lpszWrite = argv[1];
}
fSuccess = CallNamedPipe(
lpszPipename, // pipe name
lpszWrite, // message to server
(lstrlen(lpszWrite)+1)*sizeof(TCHAR), // message length
chReadBuf, // buffer to receive reply
BUFSIZE*sizeof(TCHAR), // size of read buffer
&cbRead, // number of bytes read
20000); // waits for 20 seconds
if (fSuccess || GetLastError() == ERROR_MORE_DATA)
{
_tprintf( TEXT("%s\n"), chReadBuf );
// The pipe is closed; no more data can be read.
if (! fSuccess)
{
printf("\nExtra data in message was lost\n");
}
}
_getch();
return 0;
}
Tópicos relacionados