NetworkDevice.h

Go to the documentation of this file.

#ifndef G3D_NETWORKDEVICE_H
#define G3D_NETWORKDEVICE_H

#include "G3D/platform.h"
#include "G3D/NetAddress.h"

#include <string>
#include <iostream>
#include "G3D/g3dmath.h"

#include "G3D/ReferenceCount.h"
#include "G3D/Array.h"
#include "G3D/BinaryOutput.h"

namespace G3D {

class TextOutput;
class Conduit : public ReferenceCountedObject {
protected:
 friend class NetworkDevice;
 friend class NetListener;

 uint64 mSent;
 uint64 mReceived;
 uint64 bSent;
 uint64 bReceived;

 SOCKET sock;

 BinaryOutput binaryOutput;

 Conduit();

public:

 virtual ~Conduit();
 uint64 bytesSent() const;
 uint64 messagesSent() const;
 uint64 bytesReceived() const;
 uint64 messagesReceived() const;

 virtual bool messageWaiting();

 virtual uint32 waitingMessageType() = 0;

 bool ok() const;
};

typedef shared_ptr<class ReliableConduit> ReliableConduitRef;

#ifdef __GNUC__
// Workaround for a known bug in gcc 4.x where htonl produces 
// a spurrious warning.
// http://gcc.gnu.org/ml/gcc-bugs/2005-10/msg03270.html
uint32 gcchtonl(uint32);
#endif

// Messaging and stream APIs must be supported on a single class because
// sometimes an application will switch modes on a single socket. For
// example, when transferring 3D level geometry during handshaking with
// a game server.
class ReliableConduit : public Conduit {
private:
 friend class NetworkDevice;
 friend class NetListener;

 enum State {RECEIVING, HOLDING, NO_MESSAGE} state;

 NetAddress addr;
 
 uint32 messageType;

 uint32 messageSize;

 void* receiveBuffer;

 size_t receiveBufferTotalSize;

 size_t receiveBufferUsedSize;

 ReliableConduit(const NetAddress& addr);

 ReliableConduit(const SOCKET& sock, 
 const NetAddress& addr);

 template<typename T> static void serializeMessage
 (uint32 t, const T& m, BinaryOutput& b) {

 b.writeUInt32(t);

 // Reserve space for the 4 byte size header
 b.writeUInt32(0);

 size_t L = (size_t)b.length();
 m.serialize(b);
 if ((size_t)b.length() == L) {
 // No data was created by serialization.
 // We need to send at least one byte because receive assumes that
 // a zero length message is an error.
 b.writeUInt8(0xFF);
 }
 
 uint32 len = (uint32)b.size() - 8;
 
 // We send the length first to tell recv how much data to read.
 // Here we abuse BinaryOutput a bit and write directly into
 // its buffer, violating the abstraction.
 // Note that we write to the second set of 4 bytes, which is
 // the size field.
 uint32* lenPtr = ((uint32*)b.getCArray()) + 1;
 #if defined(__GNUC__)
 *lenPtr = gcchtonl(len);
 #else
 *lenPtr = htonl(len);
 #endif
 }


 void sendBuffer(const BinaryOutput& b);

 void receiveIntoBuffer();

 void receiveHeader();

public:

 static ReliableConduitRef create(const NetAddress& address);

 ~ReliableConduit();


 virtual bool messageWaiting();

 template<typename T> inline void send(uint32 type, const T& message) {
 binaryOutput.reset();
 serializeMessage(type, message, binaryOutput);
 sendBuffer(binaryOutput);
 }
 
 void send(uint32 type);

 template<typename T>
 inline static void multisend(
 const Array<ReliableConduitRef>& array, 
 uint32 type,
 const T& m) {
 
 if (array.size() > 0) {
 array[0]->binaryOutput.reset();
 serializeMessage(type, m, array[0]->binaryOutput);

 for (int i = 0; i < array.size(); ++i) {
 array[i]->sendBuffer(array[0]->binaryOutput);
 }
 }
 }

 virtual uint32 waitingMessageType();

 template<typename T> inline bool receive(T& message) {
 if (! messageWaiting()) {
 return false;
 }

 debugAssert(state == HOLDING);
 // Deserialize
 BinaryInput b((uint8*)receiveBuffer, receiveBufferUsedSize, G3D_LITTLE_ENDIAN, BinaryInput::NO_COPY);
 message.deserialize(b);
 
 // Don't let anyone read this message again. We leave the buffer
 // allocated for the next caller, however.
 receiveBufferUsedSize = 0;
 state = NO_MESSAGE;
 messageType = 0;
 messageSize = 0;

 // Potentially read the next message.
 messageWaiting();

 return true;
 }

 inline void receive() {
 if (! messageWaiting()) {
 return;
 }
 receiveBufferUsedSize = 0;
 state = NO_MESSAGE;
 messageType = 0;
 messageSize = 0;

 // Potentially read the next message.
 messageWaiting();
 }

 NetAddress address() const;
};


typedef shared_ptr<class LightweightConduit> LightweightConduitRef;

class LightweightConduit : public Conduit {
private:
 friend class NetworkDevice;

 bool alreadyReadMessage;

 NetAddress messageSender;

 uint32 messageType;

 Array<uint8> messageBuffer;

 LightweightConduit(uint16 receivePort, bool enableReceive, bool enableBroadcast);
 
 void sendBuffer(const NetAddress& a, BinaryOutput& b);

 int MTU;


 template<typename T> 
 void serializeMessage(
 uint32 type, 
 const T& m, 
 BinaryOutput& b) const {

 debugAssert(type != 0);
 b.writeUInt32(type);
 m.serialize(b);
 b.writeUInt32(1);
 
 debugAssertM(b.size() < MTU, 
 format("This LightweightConduit is limited to messages of "
 "%d bytes (Ethernet hardware limit; this is the "
 "'UDP MTU')", maxMessageSize()));

 if (b.size() >= MTU) {
 throw LightweightConduit::PacketSizeException(
 format("This LightweightConduit is limited to messages of "
 "%d bytes (Ethernet hardware limit; this is the "
 "'UDP MTU')", maxMessageSize()),
 (int)b.size() - 4, // Don't count the type header
 maxMessageSize());
 }
 }

public:

 static LightweightConduitRef create(uint16 receivePort, bool enableReceive, bool enableBroadcast);

 class PacketSizeException {
 public:
 std::string message;
 int serializedPacketSize;
 int maxMessageSize;

 inline PacketSizeException(const std::string& m, int s, int b) :
 message(m),
 serializedPacketSize(s),
 maxMessageSize(b) {}
 };

 ~LightweightConduit();

 inline int maxMessageSize() const {
 return MTU - 4;
 }


 template<typename T> inline void send(const NetAddress& a, uint32 type, const T& msg) {
 binaryOutput.reset();
 serializeMessage(type, msg, binaryOutput);
 sendBuffer(a, binaryOutput);
 }

 template<typename T> inline void send(const Array<NetAddress>& a, uint32 type, const T& m) {
 binaryOutput.reset();
 serializeMessage(type, m, binaryOutput);

 for (int i = 0; i < a.size(); ++i) {
 sendBuffer(a[i], binaryOutput);
 }
 }

 bool receive(NetAddress& sender);

 template<typename T> inline bool receive(NetAddress& sender, T& message) {
 bool r = receive(sender);
 if (r) {
 BinaryInput b((messageBuffer.getCArray() + 4), 
 messageBuffer.size() - 4, 
 G3D_LITTLE_ENDIAN, BinaryInput::NO_COPY);
 message.deserialize(b);
 }

 return r;
 }

 inline bool receive() {
 static NetAddress ignore;
 return receive(ignore);
 }

 virtual uint32 waitingMessageType();


 virtual bool messageWaiting();
};


typedef shared_ptr<class NetListener> NetListenerRef;

class NetListener : public ReferenceCountedObject {
private:

 friend class NetworkDevice;

 SOCKET sock;

 NetListener(uint16 port);

public:

 static NetListenerRef create(const uint16 port);

 ~NetListener();

 ReliableConduitRef waitForConnection();

 bool clientWaiting() const;

 bool ok() const;
};



class NetworkDevice {
public:

 class EthernetAdapter {
 public:
 std::string hostname;

 std::string name;

 uint32 ip;

 uint32 subnet;

 uint32 broadcast;

 uint8 mac[6];

 EthernetAdapter();

 void describe(TextOutput& t) const;
 };

private:

 friend class Conduit;
 friend class LightweightConduit;
 friend class ReliableConduit;
 friend class NetListener;

 bool initialized;

 Array<EthernetAdapter> m_adapterArray;

 Array<uint32> m_broadcastAddresses;

 void closesocket(SOCKET& sock) const;

 bool bind(SOCKET sock, const NetAddress& addr) const;

 static NetworkDevice* s_instance;

 NetworkDevice();

 bool init();

 void _cleanup();

 void addAdapter(const EthernetAdapter& a);

public:

 static std::string formatIP(uint32 ip);

 static std::string formatMAC(const uint8 mac[6]);

 ~NetworkDevice();

 inline const Array<EthernetAdapter>& adapterArray() const {
 return m_adapterArray;
 }

 inline const Array<uint32>& broadcastAddressArray() const {
 return m_broadcastAddresses;
 }

 static NetworkDevice* instance();

 static void cleanup();

 void describeSystem(
 TextOutput& t);

 void describeSystem(
 std::string& s);

 std::string localHostName() const;

 void localHostAddresses(Array<NetAddress>& array) const;
};


#ifdef __GNUC__
inline uint32 gcchtonl(uint32 x) {
 // This pragma fools gcc into surpressing all error messages,
 // including the bogus one that it creates for htonl
# pragma GCC system_header
 return htonl(x);
}
#endif

} // G3D namespace

#ifndef _WIN32
#undef SOCKADDR_IN
#undef SOCKET
#endif

#endif