state(Client::READING_REQUEST),
stream(NULL),
header_or_error_bytes_sent(0),
- bytes_sent(0)
+ stream_pos(0)
{
request.reserve(1024);
stream(stream),
header_or_error(serialized.header_or_error()),
header_or_error_bytes_sent(serialized.header_or_error_bytes_sent()),
- bytes_sent(serialized.bytes_sent())
+ stream_pos(serialized.stream_pos())
{
if (stream->mark_pool != NULL) {
fwmark = stream->mark_pool->get_mark();
serialized.set_stream_id(stream_id);
serialized.set_header_or_error(header_or_error);
serialized.set_header_or_error_bytes_sent(serialized.header_or_error_bytes_sent());
- serialized.set_bytes_sent(bytes_sent);
+ serialized.set_stream_pos(stream_pos);
return serialized;
}
stats.stream_id = stream_id;
stats.remote_addr = remote_addr;
stats.connect_time = connect_time;
- stats.bytes_sent = bytes_sent;
+ stats.bytes_sent = stream_pos;
return stats;
}
}
if (client_ptr->state == Client::SENDING_DATA &&
- client_ptr->bytes_sent == client_ptr->stream->bytes_received) {
+ client_ptr->stream_pos == client_ptr->stream->bytes_received) {
client_ptr->stream->put_client_to_sleep(client_ptr);
} else {
process_client(client_ptr);
++client_it) {
Client *client = &client_it->second;
if (client->state == Client::SENDING_DATA &&
- client->bytes_sent == 0) {
+ client->stream_pos == 0) {
construct_header(client);
}
}
// but we'll start sending immediately as we get data.
// This is postcondition #3.
client->state = Client::SENDING_DATA;
- client->bytes_sent = client->stream->bytes_received;
+ client->stream_pos = client->stream->bytes_received;
client->stream->put_client_to_sleep(client);
return;
}
// See if there's some data we've lost. Ideally, we should drop to a block boundary,
// but resync will be the mux's problem.
Stream *stream = client->stream;
- size_t bytes_to_send = stream->bytes_received - client->bytes_sent;
+ size_t bytes_to_send = stream->bytes_received - client->stream_pos;
if (bytes_to_send == 0) {
return;
}
fprintf(stderr, "WARNING: fd %d lost %lld bytes, maybe too slow connection\n",
client->sock,
(long long int)(bytes_to_send - stream->backlog_size));
- client->bytes_sent = stream->bytes_received - stream->backlog_size;
+ client->stream_pos = stream->bytes_received - stream->backlog_size;
bytes_to_send = stream->backlog_size;
}
// See if we need to split across the circular buffer.
bool more_data = false;
- if ((client->bytes_sent % stream->backlog_size) + bytes_to_send > stream->backlog_size) {
- bytes_to_send = stream->backlog_size - (client->bytes_sent % stream->backlog_size);
+ if ((client->stream_pos % stream->backlog_size) + bytes_to_send > stream->backlog_size) {
+ bytes_to_send = stream->backlog_size - (client->stream_pos % stream->backlog_size);
more_data = true;
}
ssize_t ret;
do {
- loff_t offset = client->bytes_sent % stream->backlog_size;
+ loff_t offset = client->stream_pos % stream->backlog_size;
ret = sendfile(client->sock, stream->data_fd, &offset, bytes_to_send);
} while (ret == -1 && errno == EINTR);
close_client(client);
return;
}
- client->bytes_sent += ret;
+ client->stream_pos += ret;
- if (client->bytes_sent == stream->bytes_received) {
+ if (client->stream_pos == stream->bytes_received) {
// We don't have any more data for this client, so put it to sleep.
// This is postcondition #3.
stream->put_client_to_sleep(client);