PipeServer not sending text every second - c++

Question

This is the "PipeServer" in the 1st application:
// Open Pipe and wait until ControlProgram is connecting
Pipe.Out = INVALID_HANDLE_VALUE;
const wchar_t *data = L"*** Hello Pipe World ***";
DWORD numBytesWritten = 0;
DWORD timerinit = GetTickCount();;
while (1)
{
DWORD timer = GetTickCount();
if ((timer - timerinit) > 1000)
{
timerinit = timer;
if (ConnectNamedPipe(Pipe.Out, NULL))
{
WriteFile(
Pipe.Out, // handle to our outbound pipe
data, // data to send
wcslen(data) * sizeof(wchar_t), // length of data to send (bytes)
&numBytesWritten, // will store actual amount of data sent
NULL // not using overlapped IO
);
}
else
{
CloseHandle(Pipe.Out);
Pipe.Out = INVALID_HANDLE_VALUE;
do
{
Pipe.Out = CreateNamedPipeW(
L"\\\\.\\pipe\\mypipe", // name of the pipe
PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
PIPE_TYPE_BYTE, // send data as a byte stream
1, // only allow 1 instance of this pipe
0, // no outbound buffer
0, // no inbound buffer
0, // use default wait time
NULL // use default security attributes
);
}
while (Pipe.Out == INVALID_HANDLE_VALUE);
}
}
}
This is the "PipeClient" Application:
///// CLIENT PROGRAM /////
#include <iostream>
#include <windows.h>
using namespace std;
int main(int argc, const char **argv)
{
wcout << "Connecting to pipe..." << endl;
// Open the named pipe
// Most of these parameters aren't very relevant for pipes.
HANDLE pipe = CreateFileW(
L"\\\\.\\pipe\\mypipe",
GENERIC_READ, // only need read access
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (pipe == INVALID_HANDLE_VALUE)
{
wcout << "Failed to connect to pipe." << endl;
// look up error code here using GetLastError()
system("pause");
return 1;
}
wcout << "Reading data from pipe..." << endl;
while (1)
{
// The read operation will block until there is data to read
wchar_t buffer[128];
DWORD numBytesRead = 0;
BOOL result = ReadFile(
pipe,
buffer, // the data from the pipe will be put here
127 * sizeof(wchar_t), // number of bytes allocated
&numBytesRead, // this will store number of bytes actually read
NULL // not using overlapped IO
);
if (result)
{
buffer[numBytesRead / sizeof(wchar_t)] = '\0'; // null terminate the string
wcout << "Number of bytes read: " << numBytesRead << endl;
wcout << "Message: " << buffer << endl;
FlushFileBuffers(pipe);
}
else
{
wcout << "Failed to read data from the pipe." << endl;
wcout << result << endl;
CloseHandle(pipe);
break;
}
}
// Close our pipe handle
wcout << "Done." << endl;
system("pause");
return 0;
}
The server should wait for the client to connect and then send the defined message every 1 second.
The client should be able to start/restart whenever it wants.
But whenever i start the client it receives the message one time, then exits with error while reading from the pipe.
result returns 0.
UPDATE (for those who want to know how it's working now)
This is the "updated" PipeServer code:
// Open Pipe and wait until ControlProgram is connecting
Pipe.Out = INVALID_HANDLE_VALUE;
DWORD numBytesWritten = 0;
DWORD timerinit = GetTickCount();
bool connected = false;
bool writesucc = false;
bool initial = true;
while (1)
{
DWORD timer = GetTickCount();
wchar_t data[100];
if (!initial)
{
swprintf_s(data, 100, L"Time: %d", timer); // use L"" prefix for wide chars
}
else
{
swprintf_s(data, 100, L"Welcome from your Pipe Server"); // use L"" prefix for wide chars
}
if ((timer - timerinit) > 1000)
{
timerinit = timer;
if (!connected)
{
connected = ConnectNamedPipe(Pipe.Out, NULL);
}
if (connected)
{
writesucc = WriteFile(
Pipe.Out, // handle to our outbound pipe
data, // data to send
wcslen(data) * sizeof(wchar_t), // length of data to send (bytes)
&numBytesWritten, // will store actual amount of data sent
NULL // not using overlapped IO
);
if (writesucc) initial = false;
}
if ((!writesucc) || (Pipe.Out == INVALID_HANDLE_VALUE) || (!connected))
{
initial = true;
CloseHandle(Pipe.Out);
Pipe.Out = INVALID_HANDLE_VALUE;
do
{
Pipe.Out = CreateNamedPipeW(
L"\\\\.\\pipe\\mypipe", // name of the pipe
PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
PIPE_TYPE_BYTE, // send data as a byte stream
1, // only allow 1 instance of this pipe
0, // no outbound buffer
0, // no inbound buffer
0, // use default wait time
NULL // use default security attributes
);
}
while (Pipe.Out == INVALID_HANDLE_VALUE);
}
}
}

Answer 1

Your client fails because the server is calling ConnectNamedPipe() every second and then closing the connection if ConnectNamedPipe() fails because there is already a client connected and you are only allowing 1 client to be connected at a time. This is stated in the ConnectNamedPipe() documentation:
A named pipe server process can use ConnectNamedPipe with a newly created pipe instance. It can also be used with an instance that was previously connected to another client process; in this case, the server process must first call the DisconnectNamedPipe function to disconnect the handle from the previous client before the handle can be reconnected to a new client. Otherwise, ConnectNamedPipe returns zero, and GetLastError returns ERROR_NO_DATA if the previous client has closed its handle or ERROR_PIPE_CONNECTED if it has not closed its handle.
You are only writing your message one time - when ConnectNamedPipe() succeessfully creates a new connection. You are not looping the writing after that point, your next iteration calls ConnectNamedPipe() again and fails.
You are not checking any error codes from GetLastError(), otherwise you would have noticed that situation after reading the documentation to find out what the error codes mean.
Try something more like this instead:
const wchar_t *data = L"*** Hello Pipe World ***";
DWORD numBytesWritten;
Pipe.Out = CreateNamedPipeW(
L"\\\\.\\pipe\\mypipe", // name of the pipe
PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
PIPE_TYPE_BYTE, // send data as a byte stream
1, // only allow 1 instance of this pipe
0, // no outbound buffer
0, // no inbound buffer
0, // use default wait time
NULL // use default security attributes
);
if (Pipe.Out == INVALID_HANDLE_VALUE)
{
// error creating pipe
}
else
{
while (should wait for a client to connect)
{
if (!ConnectNamedPipe(Pipe.Out, NULL))
{
// if ERROR_PIPE_CONNECTED then a client is actually connected!
if (GetLastError() != ERROR_PIPE_CONNECTED)
{
// error connecting a client
break;
}
}
DWORD timerinit = GetTickCount();
while (should write to the client)
{
DWORD timer = GetTickCount();
// GetTickCount() wraps back to 0 every 49.7 days, so account for that...
DWORD elapsed = (timer >= timerinit) ? (timer - timerinit) : ((MAXDWORD - timerinit) + timer);
if (elapsed >= 1000)
{
timerinit = timer;
if (!WriteFile(
Pipe.Out, // handle to our outbound pipe
data, // data to send
wcslen(data) * sizeof(wchar_t), // length of data to send (bytes)
&numBytesWritten, // will store actual amount of data sent
NULL // not using overlapped IO
)
{
// error writing to client
break;
}
}
}
DisconnectNamedPipe(Pipe.Out);
}
CloseHandle(Pipe.Out);
}