All code highlighting was done by SourceFormatX
Class: zsocket :
Header |
HtmlAuthor: Mark, the Great and Powerful
Date of Creation: 9/2/05
Last Update: 3/11/06
Library Dependencies: Ws2_32.lib
zsocket is a handy class that I created that handles tcp communication similarily to the WinSock control. I implemented “events” (error, statechange, connectionrequest, and dataarrival) by having the client code inherit the zsocket class and override these methods. (You don't have to override any of them) All of the classes functionality is run on one seperate thread (for all instances of zsocket) so even if the thread that created the socket is busy, it can still continue to function. One thing you have to watchout for however is the fact that all the events are called by the single thread that runs all of the sockets. So if you do something in that thread that takes an excessive amount of time, no other sockets (including the current socket) can continue to function and recieve messages. Note that syncconnect and flush will allow sockets to continue to function.
Below are the avaliable functions that a deriving class can override
virtual void error(int num, std::string description) {}
virtual void statechange(SocketState oldstate) {}
virtual void connectionrequest(int requestid) {}
virtual void dataarrival(int bytessent) {}
Here is a sample cleint program using zsocket. It just simply connects to google and requests its homepage.
#include <iostream>
#include "zsocket.hpp"
using namespace std;
class mysck: public zsocket
{
public:
virtual void error(int num, std::string description)
{
cout << "Error #" << num << "\t" << description << endl;
}
virtual void statechange(SocketState oldstate)
{
if (oldstate != sckConnected && state() == sckConnected)
{
cout << "CONNECTED :D" << endl;
//issue request
sendstring("GET / HTTP/1.1\r\n\r\n");
}
}
virtual void connectionrequest(int requestid)
{
//This is a client program so it should not be recieving any requests
}
virtual void dataarrival(int bytessent)
{
//To get a string containing the data sent, call getdata()
cout << getdata() << endl;
}
};
int main()
{
//Let's try it out
zsocket * sck = new mysck();
sck->sckconnect("www.google.com", 80);
system("pause");
delete sck;
return 0;
}
Here is an example server program using zsocket. This is just a basic http server. For purposes of keeping this code segment short, it has a memory leak due to mysck instances not being deleted. After running this, try going to http://127.0.0.1
#include <iostream>
#include "zsocket.hpp"
using namespace std;
class mysck: public zsocket
{
public:
virtual void error(int num, std::string description)
{
cout << "Error #" << num << "\t" << description << endl;
}
virtual void dataarrival(int bytessent)
{
//Being a simple server, we'll just send back a hello world
sendstring("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\nHello World");
}
};
class myserver: public zsocket
{
public:
virtual void error(int num, std::string description)
{
cout << "Error #" << num << "\t" << description << endl;
}
virtual void statechange(SocketState oldstate)
{
if (oldstate != sckListening && state() == sckListening)
{
cout << "LISTENING :D" << endl;
}
}
virtual void connectionrequest(int requestid)
{
//spawn a socket to take the connection
zsocket * sck = new mysck();
sck->sckaccept(requestid);
}
virtual void dataarrival(int bytessent)
{
//This is a server socket so it shouldn't recieve data
//but it could if it later connected or accepted a connection request
}
};
int main()
{
//Let's try it out
zsocket * svr = new myserver();
svr->scklisten(80);
system("pause");
delete svr;
return 0;
}Constructor
zsocket(); //Creates a basic socket object and initializes the zsocket thread if needed
Methods
//Syncronous connect methods
bool syncconnect(std::string zhost, int zport,int timeout);
bool syncconnect(int timeout);
bool syncconnect(std::string zhost, int zport);
bool syncconnect();
//Asyncronous connect methods
void sckconnect(std::string zhost, int zport, int timeout);
void sckconnect(int timeout);
void sckconnect(std::string zhost, int zport);
void sckconnect();
//Send methods
void senddata(void * buf, int length);
void sendstring(std::string str);
void sendfile(std::string file);
//Finishes sending all data for this socket
void flush();
//Recieve methods
std::string getdata(); //Gets data and removes it from the buffer
std::string peekdata(); //Gets data but does no remove it from the buffer
//Listen functions
bool scklisten(int zport);
bool scklisten();
//Other functions
void close(); //Destroys the underlying socket object and creates a new one
void sckaccept(int requestid); //Accepts a connection request
bool waitforconnection(int timeout); //Attempts to wait for a connection request and connects to it
Properties
//Local properties
std::string localip();
std::string localhost();
//Remote properties
std::string remoteip();
std::string remotehost();
int port(); //Port to listen on or connect to
SocketState state(); //Current state of the socket
int getlasttime(); //The last time (as returned by GetTickCount()) that the socket was sending or recieving data
int timeout(); //Max timeout while attempting to connect
int maxsendbuffersize(); //the maximum amount of data in bytes that can be sent in one packet.
void sethost(std::string zhost); //Set the remote host
void setport(int zport); //Set the port to listen on or connect to
void settimeout(int ztimeout); //Set the time in milliseconds to attempt to connect