void send_fastpath_data(InStream & data) {
StaticOutStream<TRANSPARENT_CHUNK_HEADER_SIZE> header;
this->make_chunk_header(header, CHUNK_TYPE_FASTPATH, data.get_capacity());
assert(header.get_offset() == header.get_capacity());
this->t->send(header.get_data(), header.get_capacity());
this->t->send(data.get_data(), data.get_capacity());
}
void send_save_state_chunk()
{
StaticOutStream<4096> payload;
this->ssc.send(payload);
//------------------------------ missing variable length ---------------
send_wrm_chunk(this->trans, SAVE_STATE, payload.get_offset(), 1);
this->trans.send(payload.get_data(), payload.get_offset());
}
void addInclusiveRect(uint16_t left,
uint16_t top,
uint16_t right,
uint16_t bottom) {
buffer_stream.out_uint16_le(left);
buffer_stream.out_uint16_le(top);
buffer_stream.out_uint16_le(right);
buffer_stream.out_uint16_le(bottom);
area_count++;
}
virtual void operator() (uint32_t total_length, uint32_t flags,
const uint8_t * chunk_data, uint32_t chunk_data_length) override {
LOG(LOG_INFO, "total_length=%u flags=0x%X chunk_data=<%p> chunk_data_length=%u",
total_length, flags, static_cast<void const *>(chunk_data), chunk_data_length);
StaticOutStream<8> stream;
stream.out_uint32_le(total_length);
stream.out_uint32_le(flags);
this->transport.send(stream.get_data(), stream.get_offset());
this->transport.send(chunk_data, chunk_data_length);
}
void set_pointer(int cache_idx) override {
size_t size = 2 // mouse x
+ 2 // mouse y
+ 1 // cache index
;
send_wrm_chunk(this->trans, POINTER, size, 0);
StaticOutStream<16> payload;
payload.out_uint16_le(this->mouse_x);
payload.out_uint16_le(this->mouse_y);
payload.out_uint8(cache_idx);
this->trans.send(payload.get_data(), payload.get_offset());
}
void send_timestamp_chunk(bool ignore_time_interval = false)
{
StaticOutStream<12 + GTF_SIZE_KEYBUF_REC * sizeof(uint32_t) + 1> payload;
payload.out_timeval_to_uint64le_usec(this->timer);
if (this->send_input) {
payload.out_uint16_le(this->mouse_x);
payload.out_uint16_le(this->mouse_y);
payload.out_uint8(ignore_time_interval ? 1 : 0);
/*
for (uint32_t i = 0, c = keyboard_buffer_32.size() / sizeof(uint32_t);
i < c; i++) {
LOG(LOG_INFO, "send_timestamp_chunk: '%c'(0x%X)",
(keyboard_buffer_32.data[i]<128)?(char)keyboard_buffer_32.data[i]:'?',
keyboard_buffer_32.data[i]);
}
*/
payload.out_copy_bytes(keyboard_buffer_32.get_data(), keyboard_buffer_32.get_offset());
keyboard_buffer_32 = OutStream(keyboard_buffer_32_buf);
}
send_wrm_chunk(this->trans, TIMESTAMP, payload.get_offset(), 1);
this->trans.send(payload.get_data(), payload.get_offset());
this->last_sent_timer = this->timer;
}
void server_resize(uint16_t width, uint16_t height, uint8_t bpp) {
constexpr unsigned payload_size = 5;
StaticOutStream<TRANSPARENT_CHUNK_HEADER_SIZE + payload_size> header;
this->make_chunk_header(header, CHUNK_TYPE_RESIZE, payload_size);
header.out_uint16_le(width);
header.out_uint16_le(height);
header.out_uint8(bpp);
assert(header.get_offset() == header.get_capacity());
this->t->send(header.get_data(), header.get_offset());
}
void send_to_front_channel( const char * const mod_channel_name
, uint8_t const * data, size_t length
, size_t chunk_size, int flags) {
constexpr unsigned payload_size = 9;
StaticOutStream<TRANSPARENT_CHUNK_HEADER_SIZE + payload_size> header;
uint8_t mod_channel_name_length = strlen(mod_channel_name);
this->make_chunk_header(header, CHUNK_TYPE_FRONTCHANNEL, payload_size + mod_channel_name_length + length);
header.out_uint8(mod_channel_name_length);
header.out_uint16_le(length);
header.out_uint16_le(chunk_size);
header.out_uint32_le(flags);
assert(header.get_offset() == header.get_capacity());
this->t->send(header.get_data(), header.get_offset());
this->t->send(mod_channel_name, mod_channel_name_length);
this->t->send(data, length);
}
void send_data_indication_ex(uint16_t channelId, uint8_t const * packet_data, std::size_t packet_size) {
constexpr unsigned payload_size = 2;
StaticOutStream<TRANSPARENT_CHUNK_HEADER_SIZE + payload_size> header;
this->make_chunk_header(header, CHUNK_TYPE_SLOWPATH, payload_size + packet_size);
header.out_uint16_le(channelId);
assert(header.get_offset() == header.get_capacity());
this->t->send(header.get_data(), header.get_offset());
this->t->send(packet_data, packet_size);
}
void send_meta_chunk() {
const uint8_t trm_format_version = 0;
constexpr unsigned payload_size = 1;
StaticOutStream<TRANSPARENT_CHUNK_HEADER_SIZE + payload_size> header;
this->make_chunk_header(header, CHUNK_TYPE_META, payload_size);
header.out_uint8(trm_format_version);
assert(header.get_offset() == header.get_capacity());
this->t->send(header.get_data(), header.get_offset());
}
void session_update(timeval const & now, array_view_const_char message) override {
uint16_t message_length = message.size() + 1; // Null-terminator is included.
StaticOutStream<16> payload;
payload.out_timeval_to_uint64le_usec(now);
payload.out_uint16_le(message_length);
send_wrm_chunk(this->trans, SESSION_UPDATE, payload.get_offset() + message_length, 1);
this->trans.send(payload.get_data(), payload.get_offset());
this->trans.send(message.data(), message.size());
this->trans.send("\0", 1);
this->last_sent_timer = this->timer;
}
void send_pointer(int cache_idx, const Pointer & cursor) override {
size_t size = 2 // mouse x
+ 2 // mouse y
+ 1 // cache index
+ 1 // hotspot x
+ 1 // hotspot y
+ 32 * 32 * 3 // data
+ 128 // mask
;
send_wrm_chunk(this->trans, POINTER, size, 0);
StaticOutStream<16> payload;
payload.out_uint16_le(this->mouse_x);
payload.out_uint16_le(this->mouse_y);
payload.out_uint8(cache_idx);
payload.out_uint8(cursor.x);
payload.out_uint8(cursor.y);
this->trans.send(payload.get_data(), payload.get_offset());
this->trans.send(cursor.data, cursor.data_size());
this->trans.send(cursor.mask, cursor.mask_size());
}
