--- a/src/proto2/Network.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/Network.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -3,43 +3,6 @@
 #include "NetworkAddress.hh"
 #include "Engine.hh"
 
-void writeVector (CL_NetPacket &pkt, const Vector &vec) {
-    pkt.output.write_float32(vec.x);
-    pkt.output.write_float32(vec.y);
-
-/*
-    int32_t x = vec.x * COORDINATE_MAX / MAP_WIDTH;
-    int32_t y = vec.y * COORDINATE_MAX / MAP_HEIGHT;
-    
-    Engine::log(DEBUG, "network.write_vector") 
-        << "vec=" << vec << " -> x=" << x << ", y=" << y;
-
-    pkt.output.write_int32(x);
-    pkt.output.write_int32(y);
-*/    
-}
-
-Vector readVector (CL_NetPacket &pkt) {
-    float fx = pkt.input.read_float32();
-    float fy = pkt.input.read_float32();
-
-    Vector vec(fx, fy);
-
-/*    
-    int32_t x = pkt.input.read_int32();
-    int32_t y = pkt.input.read_int32();
-
-    float fx = x * MAP_WIDTH / COORDINATE_MAX;
-    float fy = y * MAP_HEIGHT / COORDINATE_MAX;
-    
-    Vector vec(fx, fy);
-
-    Engine::log(DEBUG, "network.read_vector") << "x=" << x << ", y=" << y << " -> " << vec;
-*/    
-
-    return vec;
-}
-
 std::ostream& operator<< (std::ostream &s, const NetworkAddress &addr) {
     s << "[" << addr.get_address() << ":" << addr.get_port() << "]";
 

--- a/src/proto2/NetworkNode.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkNode.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -1,7 +1,9 @@
+
+#include <cassert>
 
 #include "NetworkNode.hh"
 
-NetworkNode::NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP &udp, const NetworkAddress &address) :
+NetworkNode::NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &address) :
     session(session), tcp(tcp), udp(udp), address(address) {
     
     // connect signals
@@ -13,7 +15,7 @@
     delete tcp;
 }
 
-void on_disconnect (void) {
+void NetworkNode::on_disconnect (void) {
     // tell session
     session.handle_disconnect(this);
 
@@ -24,7 +26,7 @@
     delete this;
 }
 
-void NetworkNode::send (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable = true) {
+void NetworkNode::send (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable) {
     assert(channel_id > 0);
     
     // add our header
@@ -39,7 +41,7 @@
         tcp->write_packet(pkt2);
 
     } else {
-        udp.sendto(pkt2, address);
+        udp->sendto(pkt2, address);
     }
 }
         

--- a/src/proto2/NetworkNode.hh	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkNode.hh	Thu Nov 20 20:27:12 2008 +0000
@@ -4,27 +4,28 @@
 // forward-declare
 class NetworkNode;
 
-#include "NetworkTCP.hh"
-#include "NetworkUDP.hh"
-#include "NetworkSession.hh"
-
 enum NetworkNodeType {
     NETWORK_NODE_SERVER_CLIENT,
     NETWORK_NODE_CLIENT_SERVER
 };
 
+#include "NetworkTCP.hh"
+#include "NetworkUDP.hh"
+#include "NetworkSession.hh"
+
 class NetworkNode {
     private:
         NetworkSession &session;
         NetworkTCPTransport *tcp;
-        NetworkUDP &udp;
+        NetworkUDP *udp;
         const NetworkAddress address;
 
         CL_SlotContainer slots;
     
+    public:
+        NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &address);
+        
     private:
-        NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP &udp, const NetworkAddress &address);
-        
         NetworkNode (const NetworkNode &copy);
         ~NetworkNode (void);
         NetworkNode& operator= (const NetworkNode &copy);

--- a/src/proto2/NetworkObject.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkObject.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -1,8 +1,13 @@
+
+#include <cassert>
 
 #include "NetworkObject.hh"
 
+/* 
+ * NetworkObject_Controller 
+ */
 NetworkObjectController::NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id) :
-    session(session), channel_id(channel_id), id_pool(0) {
+    session(session), channel_id(channel_id) {
     
     // setup signals
     slot_message = session.sig_chan_message(channel_id).connect(this, &NetworkObjectController::on_message);
@@ -16,13 +21,16 @@
     NetworkObject *obj = objects[obj_id];
 
     if (obj) {
-        obj->_map_sig_message[msg_id](node, pkt);
+        obj->handle_packet(node, msg_id, pkt);
 
     } else {
         handle_create(obj_id, msg_id, pkt, node);
     }
 }
 
+/* 
+ * NetworkObject_ServerController 
+ */
 NetworkObject_ServerController::NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id) :
     NetworkObjectController(session, channel_id), id_pool(0) {
 
@@ -33,10 +41,18 @@
 }
         
 void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) {
+    (void) obj_id;
+    (void) msg_id;
+    (void) pkt;
+    (void) node;
+
     // XXX: fail
     throw CL_Error("clients cannot create objects");
 }
         
+/* 
+ * NetworkObject_ClientController *
+ */
 NetworkObject_ClientController::NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server) :
     NetworkObjectController(session, channel_id), server(server) {
 
@@ -48,13 +64,16 @@
     assert(node == server);
     
     // create new object
-    NetworkObject_Client *obj = new NetworkObject_Client(*this, node, obj_id);
+    NetworkObject_Client *obj = new NetworkObject_Client(*this, obj_id);
     
     // signal
    _sig_create(obj, msg_id, pkt); 
 }
 
-NetworkObject::NetworkObject (NetworkObjectID obj_id) :
+/* 
+ * NetworkObject 
+ */
+NetworkObject::NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id) :
     obj_id(obj_id) {
     
     assert(obj_id);
@@ -68,17 +87,28 @@
     pkt.write_packet(payload);
 }
 
+std::ostream& operator<< (std::ostream &s, const NetworkObject &obj) {
+    return s << "<NetworkObject #" << obj << ">";
+}
+
+/* 
+ * NetworkObject_Server 
+ */
 NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :
-    NetworkObject(controller.getObjectID()), controller(controller) {
+    NetworkObject(controller, controller.getObjectID()), controller(controller) {
     
 }
 
-void NetworkObject_Server::send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
-    NetworkPacket pkt;
+void NetworkObject_Server::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) {
+    _map_sig_message[msg_id](node, pkt);
+}
 
-    buildPacket(pkt, msg_id, pkt);
+void NetworkObject_Server::send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
+    NetworkPacket pkt_out;
 
-    dst->send(controller.channel_id, pkt, reliable);
+    buildPacket(pkt_out, msg_id, pkt);
+
+    dst->send(controller.channel_id, pkt_out, reliable);
 }
 
 void NetworkObject_Server::send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
@@ -86,18 +116,33 @@
 }
 
 void NetworkObject_Server::send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable) {
-    NetworkPacket pkt;
+    NetworkPacket pkt_out;
 
-    buildPacket(pkt, msg_id, pkt);
+    buildPacket(pkt_out, msg_id, pkt);
     
-    controller.session.send_all_except(controller.channel_id, pkt, black_sheep, reliable);
+    controller.session.send_all_except(controller.channel_id, pkt_out, black_sheep, reliable);
 }
-        
-void NetworkObject_Client::send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
-    NetworkPacket pkt;
-
-    buildPacket(pkt, msg_id, pkt);
-
-    controller.server->send(controller.channel_id, pkt, reliable);
+ 
+/* 
+ * NetworkObject_Client 
+ */
+NetworkObject_Client::NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id) :
+    NetworkObject(controller, id), controller(controller) { 
+    
+    // nothing
 }
 
+void NetworkObject_Client::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) {
+    assert(node == controller.server);
+
+    _map_sig_message[msg_id](pkt);
+}
+       
+void NetworkObject_Client::send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
+    NetworkPacket pkt_out;
+
+    buildPacket(pkt_out, msg_id, pkt);
+
+    controller.server->send(controller.channel_id, pkt_out, reliable);
+}
+

--- a/src/proto2/NetworkObject.hh	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkObject.hh	Thu Nov 20 20:27:12 2008 +0000
@@ -17,6 +17,8 @@
 
 class NetworkObjectController {
     friend class NetworkObject;
+    friend class NetworkObject_Server;
+    friend class NetworkObject_Client;
 
     private:
         NetworkSession &session;
@@ -46,7 +48,7 @@
         NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);
 
     protected:
-        NetworkObjectID getObjectId (void);
+        NetworkObjectID getObjectID (void);
 
         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
 };
@@ -72,18 +74,15 @@
 class NetworkObject {
     friend class NetworkObjectController;
 
-    private:
+    protected:
         NetworkObjectID obj_id;
 
-        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacket&> > _map_sig_message;
+    protected:
+        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);
         
-    protected:
-        NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);
+        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) = 0;
 
         void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);
-
-    public:
-        CL_Signal_v2<NetworkNode*, NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 };
 
 std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);
@@ -94,12 +93,20 @@
     private:
         NetworkObject_ServerController &controller;
 
+        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacket&> > _map_sig_message;
+
     public:
         NetworkObject_Server (NetworkObject_ServerController &controller);
+    
+    protected:
+        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt);
 
+    public:
         void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
         void send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
         void send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable = true);
+    
+        CL_Signal_v2<NetworkNode*, NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 };
 
 class NetworkObject_Client : public NetworkObject {
@@ -108,11 +115,17 @@
     private:
         NetworkObject_ClientController &controller;
 
+        std::map<NetworkMessageID, CL_Signal_v1<NetworkPacket&> > _map_sig_message;
+
     protected:
-        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkNode *server, NetworkObjectID id);
+        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);
+        
+        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt);
 
     public:
         void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
+        
+        CL_Signal_v1<NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 };
 
 #endif /* NETWORK_OBJECT_HH */

--- a/src/proto2/NetworkPacket.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkPacket.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -72,7 +72,7 @@
 }
         
 float NetworkPacket::read_float32 (void) {
-    /* XXX */
+    return (float) read_uint32();
 }
 
 Vector NetworkPacket::read_vector (void) {
@@ -106,8 +106,8 @@
     write_val<int8_t>(val);
 }
         
-void write_float32 (float val) {
-    /* XXX: */
+void NetworkPacket::write_float32 (float val) {
+    write_uint32((uint32_t) val);
 }
 
 void NetworkPacket::write_vector (const Vector &vec) {

--- a/src/proto2/NetworkSession.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkSession.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -1,7 +1,9 @@
 
 #include "NetworkSession.hh"
 
-NetworkSession::NetworkSession (NetworkSessionMagic magic) :
+#include <cassert>
+
+NetworkSession::NetworkSession (uint64_t magic) :
     magic(magic), tcp_srv(NULL), udp_srv(NULL), udp_client(NULL) {
    
     // nothing
@@ -15,15 +17,15 @@
     udp_srv = new NetworkUDP(addr);
     
     // connect signals
-    slots.connect(tcp->sig_client(), this, &NetworkSession::on_tcp_client);
+    slots.connect(tcp_srv->sig_client(), this, &NetworkSession::on_tcp_client);
 }
         
-NetworkNode *NetworkSession::build_node (NetworkTCPTransport *tcp_client, NetworkUDP *udp, const NetworkAddress &addr, , enum NetworkNodeType type) {
+NetworkNode *NetworkSession::build_node (NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &addr, enum NetworkNodeType type) {
     // XXX: unused
     (void) type;
 
     // create node
-    return new NetworkNode(*this, tcp_client, addr);
+    return new NetworkNode(*this, tcp, udp, addr);
 }
 
 NetworkNode* NetworkSession::connect (const NetworkAddress &addr) {
@@ -39,9 +41,9 @@
 
     // add to nodes
     nodes[addr] = client_node;
-
-    // bind signals
-    slots.connect(tcp_client->sig_disconnect(), this, &NetworkSession::on_disconnect, client_node);
+    
+    // return the "server" node
+    return client_node;
 }
         
 void NetworkSession::on_tcp_client (NetworkTCPTransport *tcp_client) {
@@ -49,13 +51,13 @@
     NetworkAddress addr = tcp_client->getRemoteAddress();
 
     // build client
-    NetworkNode *client_node = build_node(tcp_client, udp_server, addr, NETWORK_NODE_SERVER_CLIENT);
+    NetworkNode *client_node = build_node(tcp_client, udp_srv, addr, NETWORK_NODE_SERVER_CLIENT);
 
     // add to nodes
     nodes[addr] = client_node;
 
     // fire signals
-    _sig_node_connected(node);
+    _sig_node_connected(client_node);
 }
         
 void NetworkSession::handle_disconnect (NetworkNode *node) {
@@ -64,7 +66,7 @@
 }
         
 void NetworkSession::send_all (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable) {
-    send_all_except(NULL, reliable);
+    send_all_except(channel_id, pkt, NULL, reliable);
 }
         
 void NetworkSession::send_all_except (NetworkChannelID channel_id, const NetworkPacket &pkt, const NetworkNode *node, bool reliable) {

--- a/src/proto2/NetworkSession.hh	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkSession.hh	Thu Nov 20 20:27:12 2008 +0000
@@ -1,6 +1,8 @@
 #ifndef NETWORK_SESSION_HH
 #define NETWORK_SESSION_HH
 
+#include <map>
+
 // forward-declare
 class NetworkSession;
 
@@ -13,9 +15,9 @@
 #include "NetworkUDP.hh"
 #include "NetworkNode.hh"
 
-#include <map>
+class NetworkSession {
+    friend class NetworkNode;
 
-class NetworkSession {
     private:
         uint64_t magic;
         NetworkTCPServer *tcp_srv;
@@ -34,10 +36,11 @@
     
     protected:
         virtual NetworkNode *build_node (NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &addr, enum NetworkNodeType type);
+        
+        void handle_disconnect (NetworkNode *node);
 
     private:
         void on_tcp_client (NetworkTCPTransport *client);
-        void handle_disconnect (NetworkNode *node);
 
          CL_Signal_v1<NetworkNode*> _sig_node_connected;
 

--- a/src/proto2/NetworkTCP.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkTCP.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -9,17 +9,17 @@
     
     // allocate initial buffer
     if ((buf = (char *) malloc(size_hint)) == NULL)
-       throw CL_Error("malloc failed");
+       throw NetworkBufferError("malloc failed");
     
     // remember size
     size = size_hint;
 }
         
-~NetworkBuffer::NetworkBuffer (void) {
+NetworkBuffer::~NetworkBuffer (void) {
     free(buf);
 }
 
-void NetworkBuffer::resize (size_t suffix_size) {
+void NetworkBuffer::resize (size_t item_size) {
     size_t new_size = size;
 
     // grow new_size until item_size fits
@@ -30,7 +30,7 @@
     if (new_size != size) {
         // realloc buffer
         if ((buf = (char *) realloc((void *) buf, new_size)) == NULL)
-            throw CL_Error("realloc failed");
+            throw NetworkBufferError("realloc failed");
 
         // update size
         size = new_size;
@@ -42,13 +42,13 @@
         
 void NetworkBuffer::trim (size_t prefix_size) {
     // update offset
-    offset -= prefix;
+    offset -= prefix_size;
 
     // shift the buffer forwards from (buf + prefix) -> (buf), copying (old_offset - prefix) bytes
-    memmove(buf, buf + ret, offset);
+    memmove(buf, buf + prefix_size, offset);
 }
      
-bool try_read (size_t item_size) {
+bool NetworkBuffer::try_read (size_t item_size) {
     int ret;
     size_t to_read = item_size;
 
@@ -70,35 +70,37 @@
             throw;
     }
 
+    assert(ret > 0);
+
     // update offset
     offset += ret;
 
     // did we get enough?
-    if (ret < item_size)
+    if ((unsigned int) ret < item_size)
         return false;
     else
         return true;
 } 
         
-bool peek_prefix (uint16_t &ref) {
+bool NetworkBuffer::peek_prefix (uint16_t &ref) {
     if (offset < sizeof(uint16_t))
         return false;
 
-    ret = ntohs(*((uint16_t *) (buf)));
+    ref = ntohs(*((uint16_t *) (buf)));
 
     return true;
 }
     
-bool peek_prefix (uint32_t &ref) {
+bool NetworkBuffer::peek_prefix (uint32_t &ref) {
     if (offset < sizeof(uint32_t))
         return false;
 
-    ret = ntohl(*((uint32_t *) (buf)));
+    ref = ntohl(*((uint32_t *) (buf)));
 
     return true;
 }
 
-template <typename PrefixType> PrefixType read_prefix (char *buf_ptr, size_t buf_max) {
+template <typename PrefixType> PrefixType NetworkBuffer::read_prefix (char *buf_ptr, size_t buf_max) {
     PrefixType prefix = 0;
     size_t missing = 0;
     
@@ -143,7 +145,7 @@
         // trim the bytes out
         trim(prefix);
         
-        throw CL_Error("recv prefix overflow");   
+        throw NetworkBufferError("recv prefix overflow");   
     }
 }
    
@@ -166,12 +168,12 @@
         
         // if we managed to send something, adjust buf/size and buffer
         if (ret > 0) {
+            // sanity-check
+            assert(buf_size >= (unsigned int) ret);
+
             buf_ptr += ret;
             buf_size -= ret;
 
-            // sanity-check
-            assert(buf_size >= 0);
-
             // if that was all, we're done
             if (buf_size == 0)
                 return;
@@ -194,7 +196,7 @@
     
     // attempt to write as much as possible
     try {
-        ret = socket.send(buf, offset)
+        ret = socket.send(buf, offset);
 
     } catch (CL_Error &e) {
         // ignore EAGAIN and just return
@@ -210,13 +212,13 @@
 }
         
 template <typename PrefixType> void NetworkBuffer::write_prefix (char *buf, PrefixType prefix) {
-    push_write(&prefix, sizeof(PrefixType)); 
+    push_write((char*) &prefix, sizeof(PrefixType)); 
     push_write(buf, prefix);
 }
 
 
-NetworkTCPTransport::NetworkTCPTransport (CL_Socket socket) :
-    socket(socket), in(NETWORK_TCP_INITIAL_IN_BUF), out(NETWORK_TCP_INITIAL_OUT_BUF) {
+NetworkTCPTransport::NetworkTCPTransport (NetworkSocket socket) :
+    socket(socket), in(socket, NETWORK_TCP_INITIAL_IN_BUF), out(socket, NETWORK_TCP_INITIAL_OUT_BUF) {
     
     // use nonblocking sockets
     socket.set_nonblocking(true);
@@ -224,7 +226,7 @@
     // connect signals
     slots.connect(socket.sig_read_triggered(), this, &NetworkTCPTransport::on_read);
     slots.connect(socket.sig_write_triggered(), this, &NetworkTCPTransport::on_write);
-    slots.connect(socket.sig_disconnected_triggered(), this, &NetworkTCPTransport::on_disconnected);
+    slots.connect(socket.sig_disconnected(), this, &NetworkTCPTransport::on_disconnected);
 }
 
 
@@ -233,7 +235,7 @@
     NetworkPacket packet;
     
     // let the in stream read length-prefixed packets and pass them on to handle_packet
-    while ((prefix = in.read_prefix(packet.get_buf(), packet.get_buf_size)) > 0) {
+    while ((prefix = in.read_prefix<uint16_t>(packet.get_buf(), packet.get_buf_size())) > 0) {
         packet.set_data_size(prefix);
         _sig_packet(packet);
     }
@@ -256,11 +258,11 @@
         throw CL_Error("send prefix overflow");
 
     // just write to the output buffer
-    out.write_prefix(packet.get_buf(), prefix);
+    out.write_prefix<uint16_t>((char *) packet.get_buf(), prefix);
 }
 
 NetworkTCPServer::NetworkTCPServer (const NetworkAddress &listen_addr) :
-    socket(tcp, ipv4) {
+    socket(CL_Socket::tcp, CL_Socket::ipv4) {
     
     // bind
     socket.bind(listen_addr);
@@ -284,12 +286,12 @@
     _sig_client(client);
 }
         
-virtual NetworkTCPTransport NetworkTCPServer::buildTransport (CL_Socket &socket) {
-    return new NetworkTCPTransport(client_sock);
+NetworkTCPTransport* NetworkTCPServer::buildTransport (CL_Socket &socket) {
+    return new NetworkTCPTransport(socket);
 }
         
 NetworkTCPClient::NetworkTCPClient (const NetworkAddress &connect_addr) :
-    NetworkTCPTransport(NetworkSocket(tcp, ipv4)) {
+    NetworkTCPTransport(NetworkSocket(CL_Socket::tcp, CL_Socket::ipv4)) {
 
     // connect
     socket.connect(connect_addr);

--- a/src/proto2/NetworkTCP.hh	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkTCP.hh	Thu Nov 20 20:27:12 2008 +0000
@@ -1,6 +1,8 @@
 #ifndef NETWORK_TCP_HH
 #define NETWORK_TCP_HH
 
+#include <ClanLib/core.h>
+
 #include "NetworkSocket.hh"
 #include "NetworkAddress.hh"
 #include "NetworkPacket.hh"
@@ -15,22 +17,27 @@
         NetworkDisconnectError (const std::string &message) : Error(message) { }
 };
 
+class NetworkBufferError : public Error {
+    public:
+        NetworkBufferError (const std::string &message) : Error(message) { }
+};
+
 class NetworkBuffer {
     private:
+        NetworkSocket &socket;
+
         char *buf;
-        size_t size, off;
-
-        NetworkSocket &socket;
+        size_t size, offset;
     
     public:
         NetworkBuffer (NetworkSocket &socket, size_t size_hint);
+        ~NetworkBuffer (void);
     
     private:
         NetworkBuffer (const NetworkBuffer &copy);
-        ~NetworkBuffer (void);
         NetworkBuffer& operator= (const NetworkBuffer &copy);
 
-        void resize (size_t suffix_size);
+        void resize (size_t item_size);
         void trim (size_t prefix_size);
 
     public:    
@@ -38,23 +45,22 @@
         void flush_write (void);
         template <typename PrefixType> void write_prefix (char *buf, PrefixType prefix);
         
-        void try_read (size_t item_size);
+        bool try_read (size_t item_size);
         bool peek_prefix (uint16_t &ref);
         bool peek_prefix (uint32_t &ref);
         template <typename PrefixType> PrefixType read_prefix (char *buf_ptr, size_t buf_max);
 };
 
 class NetworkTCPTransport {
-    private:
+    protected:
         NetworkSocket socket;
 
         NetworkBuffer in, out;
     
-    protected:
         CL_SlotContainer slots; 
     
     public:
-        NetworkTCPTransport (CL_Socket &socket);
+        NetworkTCPTransport (NetworkSocket socket);
 
     private:
         void on_read (void);
@@ -69,14 +75,16 @@
 
         void write_packet (const NetworkPacket &packet);
         
-        CL_Signal_v1<const NetworkPacket&> sig_packet (void) { return _sig_packet; }
-        CL_Signal_v0 sig_disconnect (void) { return _sig_disconnect; }
+        CL_Signal_v1<const NetworkPacket&>& sig_packet (void) { return _sig_packet; }
+        CL_Signal_v0& sig_disconnect (void) { return _sig_disconnect; }
 };
 
 class NetworkTCPServer {
     private:
         NetworkSocket socket;
 
+        CL_SlotContainer slots; 
+
     public:
         NetworkTCPServer (const NetworkAddress &listen_addr);
 
@@ -86,10 +94,10 @@
         CL_Signal_v1<NetworkTCPTransport *> _sig_client;
 
     protected:
-        virtual NetworkTCPTransport buildTransport (CL_Socket &socket);
+        virtual NetworkTCPTransport* buildTransport (CL_Socket &socket);
 
     public:
-        CL_Signal_v1<NetworkTCPTransport *> sig_client (void) { return _sig_client; }
+        CL_Signal_v1<NetworkTCPTransport *>& sig_client (void) { return _sig_client; }
 };
 
 class NetworkTCPClient : public NetworkTCPTransport {

--- a/src/proto2/NetworkUDP.cc	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkUDP.cc	Thu Nov 20 20:27:12 2008 +0000
@@ -1,8 +1,11 @@
 
 #include "NetworkUDP.hh"
 
+#include <ClanLib/core.h>
+#include <cassert>
+
 NetworkUDP::NetworkUDP (void) : 
-    socket(udp, ipv4) {
+    socket(CL_Socket::udp, CL_Socket::ipv4) {
     
     // do not bind
 
@@ -11,7 +14,7 @@
 }
 
 NetworkUDP::NetworkUDP (const NetworkAddress &bind_addr) :
-    socket(udp, ipv4) {
+    socket(CL_Socket::udp, CL_Socket::ipv4) {
     
     // bind socket
     socket.bind(bind_addr);
@@ -40,7 +43,7 @@
     pkt.set_data_size(ret);
 
     // handle packet
-    sig_packet(pkt, src);
+    _sig_packet(pkt, src);
 }
         
 bool NetworkUDP::sendto (const NetworkPacket &packet, const NetworkAddress &dst) {
@@ -48,15 +51,17 @@
 
     // XXX: shouldn't get trimmed
     try {
-        ret =socket.send(packet.get_buf(), packet.get_data_size(), dst);
+        ret = socket.send(packet.get_buf(), packet.get_data_size(), dst);
 
     } catch (CL_Error &e) {
         // XXX: catch some errors, but not others?
         return false;
     }
+
+    assert(ret > 0);
     
     // UDP shouldn't trim packets
-    assert(ret == packet.get_data_size());
+    assert((unsigned int) ret == packet.get_data_size());
     
     // good
     return true;

--- a/src/proto2/NetworkUDP.hh	Thu Nov 20 19:25:56 2008 +0000
+++ b/src/proto2/NetworkUDP.hh	Thu Nov 20 20:27:12 2008 +0000
@@ -2,6 +2,8 @@
 #define NETWORK_UDP_HH
 
 #include "NetworkSocket.hh"
+#include "NetworkAddress.hh"
+#include "NetworkPacket.hh"
 
 class NetworkUDP {
     private:
@@ -16,12 +18,12 @@
     private:
         void on_recv (void);
 
-        CL_Signal_v2<const NetworkPacket &, const NetworkAddress> _sig_packet;
+        CL_Signal_v2<NetworkPacket &, const NetworkAddress> _sig_packet;
 
     public:
         bool sendto (const NetworkPacket &packet, const NetworkAddress &dst);
         
-        CL_Signal_v2<const NetworkPacket &, const NetworkAddress> sig_packet (void) { return _sig_packet; }
+        CL_Signal_v2<NetworkPacket &, const NetworkAddress>& sig_packet (void) { return _sig_packet; }
 };
 
 #endif /* NETWORK_UDP_HH */