|
// IPAddr represents workstations network address
// NetSender - Interface for network sending provider
// NetReceiver - Interface for network receiving provider
// Declaration file
//
// (c) Lev Naumov, CAMEL Laboratory
// E-mail: camellab@mail.ru
// For more information see http://camel.ifmo.ru or
// http://www.codeproject.com/internet/ctp.asp
/////////////////////////////////////////////////////////////////////////////
#include "SmartBuffer.h"
union IPAddr
{
// Data type for solid representation
typedef unsigned __int32 IPSolid;
// Actual data
struct IPBytes {
unsigned char b1,b2,b3,b4;
} Bytes;
IPSolid Solid;
// Constructors
IPAddr() {SetLocalhost();};
IPAddr(unsigned char b1,unsigned char b2,unsigned char b3,unsigned char b4) {Bytes.b1=b1;Bytes.b2=b2;Bytes.b3=b3;Bytes.b4=b4;};
IPAddr(IPSolid l) {Solid=l;};
// Returns true is this ip-address refers to localhost (127.0.0.1)
inline bool IsLocalhost() {return Bytes.b1==127&&Bytes.b2==0&&Bytes.b3==0&&Bytes.b4==1;};
// Returns true is this ip-address refers to broadcasting address
// (255.255.255.255)
inline bool IsBroadcasting() {return Bytes.b1==255&&Bytes.b2==255&&Bytes.b3==255&&Bytes.b4==255;};
// Returns via s and return value dotted string representation of ip-address
inline LPTSTR GetString(LPTSTR s) {sprintf(s,"%d.%d.%d.%d",Bytes.b1,Bytes.b2,Bytes.b3,Bytes.b4); return s;};
// Set stored ip address to value, represented with string s (in
// dot-separated format). Returns true if succeeded and false otherwise
bool FromString(LPTSTR s);
// Set ip address to localhost (127.0.0.1)
inline void SetLocalhost() {Bytes.b1=127;Bytes.b2=0;Bytes.b3=0;Bytes.b4=1;};
// Set ip address to broadcasting address (255.255.255.255)
inline void SetBroadcast() {Bytes.b1=255;Bytes.b2=255;Bytes.b3=255;Bytes.b4=255;};
// Operators
bool operator ==(unsigned long ip) {return Solid==ip;};
bool operator ==(IPAddr ip) {return Solid==ip.Solid;};
bool operator !=(unsigned long ip) {return Solid!=ip;};
bool operator !=(IPAddr ip) {return Solid!=ip.Solid;};
IPAddr& operator =(const unsigned long ip) {Solid=ip; return *this;};
IPAddr& operator =(const IPAddr ip) {Solid=ip.Solid; return *this;};
};
class NetSender
{
public:
// Send smart buffer sb to address to. Parameter command represents command
// id. Parameter options - sending options. If parameter storeiffail is
// true then sent command will be stored in sent packets storage even if
// sending fails and will not overwise. Returns true if succeeded (message
// has gone) and false otherwise
virtual bool Send(SmartBuffer& sb, unsigned __int16 command, IPAddr to, unsigned __int8 options=0, bool storeiffail=true)=0;
// Returns true if sender is working (is not suspended and so on) and false
// otherwise. Default implementation returns true, because implementation
// of many protocols cannot be switched off and cannot handle errors at all
virtual bool IsWorking() {return true;};
};
class NetReceiver
{
public:
// Is called when have received data pointed by data
virtual void OnReceive(void* data)=0;
// Is called when there was an error, described with data pointed by data
virtual void OnError(void* data)=0;
};
|
By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.
If a file you wish to view isn't highlighted, and is a text file (not binary), please
let us know and we'll add colourisation support for it.
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here
Lev Naumov.
MSc in Computer Science. Graduated from Computer Technologies Department of Saint-Petersburg State University of Information Technologies, Mechanics and Optics.
Worked as C/C++ and Java programmer. Now - the research worker in "CAMEL Laboratory" and PhD student in Computer Technologies Department of Saint-Petersburg State University of Information Technologies, Mechanics and Optics.
Has scientific achievements in field of physics, automata theory, cellular automata theory, cluster computing. There are some publications.