Top: Networking: Examples
Example 1. A simple IP client that tries to retrieve the main page at www.yahoo.com via an HTTP request.
#include <pinet.h>
USING_PTYPES
int main()
{
ipstream client("www.yahoo.com", 80);
try
{
client.open();
// send a valid HTTP/1.1 request
client.put("GET / HTTP/1.1\r\n"
"Accept: * /*\r\n"
"User-Agent: TestAgent/1.0\r\n"
"Host: www.yahoo.com\r\n"
"Connection: close\r\n\r\n");
client.flush();
// receive the response and print it line by line
while (!client.get_eof())
pout.putline(client.line());
client.close();
}
catch(estream* e)
{
perr.putf("Error: %s\n", pconst(e->get_message()));
delete e;
}
return 0;
}
Example 2 . This example demonstrates the basic usage of streaming network interfaces ipstream and ipstmserver. It consists of two programs: test client and test server. The server handles requests that contain a single word "Hello" by sending a response greeting back to the client. This example would work for named pipes as well, i.e. if you replace the class names ipstream and ipstmserver with namedpipe and npserver and fix the construction parameters.
Client:
#include <pinet.h>
USING_PTYPES
const int testport = 8085;
const int maxtoken = 4096;
int main()
{
// create a client socket and send a greeting to the server
// assuming that the server is on the same host (127.0.0.1)
ipstream client(ipaddress(127, 0, 0, 1), testport);
try
{
client.open();
pout.put("Sending a request to the server...\n");
client.putline("Hello");
client.flush();
// receive the response
string rsp = client.line(maxtoken);
pout.putf("Received: %s\n", pconst(rsp));
// need to close the socket explicitly to gracefully shutdown
// the peer host too. otherwise, ~ipstream() will call cancel()
// and leave the peer in a waiting state (not forever though).
client.close();
}
catch(estream* e)
{
perr.putf("Error: %s\n", pconst(e->get_message()));
delete e;
}
return 0;
}
Server:
#include <ptime.h>
#include <pinet.h>
USING_PTYPES
const int testport = 8085;
const int maxtoken = 4096;
void servermain(ipstmserver& svr)
{
ipstream client;
pout.putf("Ready to answer queries on port %d\n", testport);
while(true)
{
// serve() will wait for a connection request and will prepare
// the supplied ipstream object for talking to the peer.
// note that (unlikely) exceptions thrown in serve() will be
// caught in main()
svr.serve(client);
// for better performance the server would start a new thread
// for each client request. for simplicity, we serve the request
// in-place. see multithreading examples for the full multithreaded
// server template.
if (client.get_active())
{
try
{
// read the request line:
// real-world network applications should limit input data
// to prevent potential denial-of-service attacks
string req = lowercase(client.line(maxtoken));
if (req == "hello")
{
// try to reverse-lookup the client's IP
string host = phostbyaddr(client.get_ip());
if (isempty(host))
host = iptostring(client.get_ip());
// now send our greeting to the client
client.putline("Hello, " + host + " ("
+ iptostring(client.get_ip()) + "), nice to see you!");
client.flush();
// log this request
pout.putf("%t greeting received from %s (%a)\n",
now(), pconst(host), long(client.get_ip()));
}
client.close();
}
catch(estream* e)
{
perr.putf("Error: %s\n", pconst(e->get_message()));
delete e;
}
}
}
}
int main()
{
ipstmserver svr;
try
{
// bind to all local addresses on port 8085
svr.bindall(testport);
// enter an infinite loop of serving requests
servermain(svr);
}
catch(estream* e)
{
perr.putf("FATAL: %s\n", pconst(e->get_message()));
delete e;
}
return 0;
}
Example 3 . This example demonstrates the use of message-oriented networking interfaces ipmessage and ipmsgserver. The client sends a broadcast message to the local network and waits for a response. It may retry the request several times.
Client:
#include <pinet.h>
USING_PTYPES
const int testport = 8085;
const int maxtoken = 4096;
const int tries = 3;
const int firsttimeout = 2000;
bool dorequest(int timeout)
{
ipmessage msg(ipbcast, testport);
try
{
pout.put("Broadcasting a request...\n");
msg.send("Hello");
// wait for a response the specified amount of time
if (!msg.waitfor(timeout))
return false;
ipaddress src;
string rsp = msg.receive(maxtoken, src);
pout.putf("Received: '%s' (from %a)\n", pconst(rsp), long(src));
}
catch(estream* e)
{
perr.putf("Error: %s\n", pconst(e->get_message()));
delete e;
}
return true;
}
int main()
{
int timeout = firsttimeout;
for (int i = 0; i < tries; i++)
{
if (dorequest(timeout))
break;
// double the timeout value
timeout *= 2;
}
return 0;
}
Server:
#include <ptime.h>
#include <pinet.h>
USING_PTYPES
const int testport = 8085;
const int maxtoken = 4096;
void servermain(ipmsgserver& svr)
{
pout.putf("Ready to answer queries on port %d\n", testport);
bool quit = false;
do
{
try
{
// receive the "hello" request and send a simple answer
// back to the client
string req = lowercase(svr.receive(maxtoken));
if (req == "hello")
{
string host = svr.get_host();
if (isempty(host))
host = iptostring(svr.get_ip());
svr.send("Hello, " + host + " ("
+ iptostring(svr.get_ip()) + "), nice to see you!");
// log this request
pout.putf("%t greeting received from %s (%a)\n",
now(), pconst(host), long(svr.get_ip()));
}
}
catch(estream* e)
{
perr.putf("Server error: %s\n", pconst(e->get_message()));
delete e;
}
} while (!quit);
}
int main()
{
ipmsgserver svr;
try
{
svr.bindall(testport);
// try to listen on socket once to generate an error right away,
// before entering the main server loop
svr.poll();
// enter an infinite loop of serving requests
servermain(svr);
}
catch(estream* e)
{
perr.putf("FATAL: %s\n", pconst(e->get_message()));
delete e;
}
return 0;
}
See also: ipstream, ipstmserver, ipmessage, ipmsgserver, Utilities, Multithreading examples