kg: comparison src/proto2/NetworkTCP.cc

equal deleted inserted replaced

-:785d220fc6b7
+:ed2957490bbf
 NetworkBuffer::NetworkBuffer (NetworkSocket &socket, size_t size_hint) :
 socket(socket), buf(0), size(0), offset(0) {
 // 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
 while (offset + item_size > new_size)
 new_size *= 2;
 // grow if needed
 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;
 } else if (new_size > (offset + item_size) * 4) {
 }
 }
 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;
 // keept reads at at least NETWORK_CHUNK_SIZE bytes
 if (to_read < NETWORK_TCP_CHUNK_SIZE)
 return false;
 else
 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;
 do {
 // do we have the prefix?
 } else {
 // trim the bytes out
 trim(prefix);
-throw CL_Error("recv prefix overflow");
+throw NetworkBufferError("recv prefix overflow");
 }
 }
 void NetworkBuffer::push_write (char *buf_ptr, size_t buf_size) {
 int ret;
 ret = -1;
 }
 // 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;
 }
 if (offset == 0)
 return;
 // 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
 if (errno == EAGAIN)
 return;
 // trim the buffer
 trim(ret);
 }
 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) :
+NetworkTCPTransport::NetworkTCPTransport (NetworkSocket socket) :
-socket(socket), in(NETWORK_TCP_INITIAL_IN_BUF), out(NETWORK_TCP_INITIAL_OUT_BUF) {
+socket(socket), in(socket, NETWORK_TCP_INITIAL_IN_BUF), out(socket, NETWORK_TCP_INITIAL_OUT_BUF) {
 // use nonblocking sockets
 socket.set_nonblocking(true);
 // 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);
 }
 void NetworkTCPTransport::on_read (void) {
 uint16_t prefix;
 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);
 }
 }
 if (prefix != packet.get_data_size())
 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);
 // assign slots
 // let our user handle it
 _sig_client(client);
 }
-virtual NetworkTCPTransport NetworkTCPServer::buildTransport (CL_Socket &socket) {
+NetworkTCPTransport* NetworkTCPServer::buildTransport (CL_Socket &socket) {
-return new NetworkTCPTransport(client_sock);
+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);
 }

branch	no-netsession
changeset 37	ed2957490bbf
parent 34	1ea6554d703e
child 38	4189b8bf3a5b