def _add_chunks_to_queue(self,
chunks,
start_send_cb=None,
end_send_cb=None):
""" the write_lock must be held when calling this function """
counter = 0
items = []
for proto_flags, index, level, data in chunks:
scb, ecb = None, None
#fire the start_send_callback just before the first packet is processed:
if counter == 0:
scb = start_send_cb
#fire the end_send callback when the last packet (index==0) makes it out:
if index == 0:
ecb = end_send_cb
payload_size = len(data)
actual_size = payload_size
if self.cipher_out:
proto_flags |= FLAGS_CIPHER
#note: since we are padding: l!=len(data)
padding_size = self.cipher_out_block_size - (
payload_size % self.cipher_out_block_size)
if padding_size == 0:
padded = data
else:
# pad byte value is number of padding bytes added
padded = memoryview_to_bytes(data) + pad(
self.cipher_out_padding, padding_size)
actual_size += padding_size
assert len(
padded
) == actual_size, "expected padded size to be %i, but got %i" % (
len(padded), actual_size)
data = self.cipher_out.encrypt(padded)
assert len(
data
) == actual_size, "expected encrypted size to be %i, but got %i" % (
len(data), actual_size)
cryptolog("sending %s bytes %s encrypted with %s padding",
payload_size, self.cipher_out_name, padding_size)
if proto_flags & FLAGS_NOHEADER:
assert not self.cipher_out
#for plain/text packets (ie: gibberish response)
log("sending %s bytes without header", payload_size)
items.append((data, scb, ecb))
elif actual_size < PACKET_JOIN_SIZE:
if type(data) not in JOIN_TYPES:
data = bytes(data)
header_and_data = pack_header(proto_flags, level, index,
payload_size) + data
items.append((header_and_data, scb, ecb))
else:
header = pack_header(proto_flags, level, index, payload_size)
items.append((header, scb, None))
items.append((strtobytes(data), None, ecb))
counter += 1
if self._write_thread is None:
self.start_write_thread()
self._write_queue.put(items)
self.output_packetcount += 1
def test_roundtrip(self):
print("hello")
for encode_flag in (FLAGS_BENCODE, FLAGS_RENCODE, FLAGS_YAML):
for comp_flag in (ZLIB_FLAG, LZ4_FLAG, LZO_FLAG, BROTLI_FLAG):
for cipher in (0, FLAGS_CIPHER):
for level in (0, 1, 10):
for index in (0, 1, 255):
for size in (0, 1, 2**8, 2**16, 2**24):
proto_flags = encode_flag | comp_flag | cipher
header = pack_header(proto_flags, level, index,
size)
assert header
uproto_flags, ulevel, uindex, usize = unpack_header(
header)[1:]
assert uproto_flags == proto_flags
assert ulevel == level
assert uindex == index
assert usize == size
for i in range(0, len(header) - 1):
try:
unpack_header(header[:i])
except Exception:
pass
else:
raise Exception(
"header unpacking should have failed for size %i"
% i)
def pack_one_packet(packet):
ee = get_enabled_encoders()
if ee:
e = get_encoder(ee[0])
data, flags = e(packet)
return pack_header(flags, 0, 0, len(data)) + data
return str(packet)
def pack_one_packet(packet):
from xpra.net.header import pack_header
ee = get_enabled_encoders()
if ee:
e = get_encoder(ee[0])
data, flags = e(packet)
return pack_header(flags, 0, 0, len(data)) + data
return str(packet)
def _add_chunks_to_queue(self, chunks, start_send_cb=None, end_send_cb=None):
""" the write_lock must be held when calling this function """
counter = 0
items = []
for proto_flags,index,level,data in chunks:
scb, ecb = None, None
#fire the start_send_callback just before the first packet is processed:
if counter==0:
scb = start_send_cb
#fire the end_send callback when the last packet (index==0) makes it out:
if index==0:
ecb = end_send_cb
payload_size = len(data)
actual_size = payload_size
if self.cipher_out:
proto_flags |= FLAGS_CIPHER
#note: since we are padding: l!=len(data)
padding_size = self.cipher_out_block_size - (payload_size % self.cipher_out_block_size)
if padding_size==0:
padded = data
else:
# pad byte value is number of padding bytes added
padded = data + pad(self.cipher_out_padding, padding_size)
actual_size += padding_size
assert len(padded)==actual_size, "expected padded size to be %i, but got %i" % (len(padded), actual_size)
data = self.cipher_out.encrypt(padded)
assert len(data)==actual_size, "expected encrypted size to be %i, but got %i" % (len(data), actual_size)
cryptolog("sending %s bytes %s encrypted with %s padding", payload_size, self.cipher_out_name, padding_size)
if proto_flags & FLAGS_NOHEADER:
assert not self.cipher_out
#for plain/text packets (ie: gibberish response)
log("sending %s bytes without header", payload_size)
items.append((data, scb, ecb))
elif actual_size<PACKET_JOIN_SIZE:
if type(data) not in JOIN_TYPES:
data = bytes(data)
header_and_data = pack_header(proto_flags, level, index, payload_size) + data
items.append((header_and_data, scb, ecb))
else:
header = pack_header(proto_flags, level, index, payload_size)
items.append((header, scb, None))
items.append((strtobytes(data), None, ecb))
counter += 1
self._write_queue.put(items)
self.output_packetcount += 1
def _add_chunks_to_queue(self, chunks, proto_flags, start_send_cb=None, end_send_cb=None):
""" the write_lock must be held when calling this function """
counter = 0
items = []
for index,level,data in chunks:
scb, ecb = None, None
#fire the start_send_callback just before the first packet is processed:
if counter==0:
scb = start_send_cb
#fire the end_send callback when the last packet (index==0) makes it out:
if index==0:
ecb = end_send_cb
payload_size = len(data)
actual_size = payload_size
if self.cipher_out:
proto_flags |= FLAGS_CIPHER
#note: since we are padding: l!=len(data)
padding = (self.cipher_out_block_size - len(data) % self.cipher_out_block_size) * " "
if len(padding)==0:
padded = data
else:
padded = data+padding
actual_size = payload_size + len(padding)
assert len(padded)==actual_size
data = self.cipher_out.encrypt(padded)
assert len(data)==actual_size
log("sending %s bytes encrypted with %s padding", payload_size, len(padding))
if proto_flags & FLAGS_NOHEADER:
#for plain/text packets (ie: gibberish response)
items.append((data, scb, ecb))
elif actual_size<PACKET_JOIN_SIZE:
if type(data) not in JOIN_TYPES:
data = bytes(data)
header_and_data = pack_header(proto_flags, level, index, payload_size) + data
items.append((header_and_data, scb, ecb))
else:
header = pack_header(proto_flags, level, index, payload_size)
items.append((header, scb, None))
items.append((strtobytes(data), None, ecb))
counter += 1
self._write_queue.put(items)
self.output_packetcount += 1
def _add_chunks_to_queue(self, chunks, start_send_cb=None, end_send_cb=None, fail_cb=None, synchronous=True, more=False):
""" the write_lock must be held when calling this function """
counter = 0
items = []
for proto_flags,index,level,data in chunks:
payload_size = len(data)
actual_size = payload_size
if self.cipher_out:
proto_flags |= FLAGS_CIPHER
#note: since we are padding: l!=len(data)
padding_size = self.cipher_out_block_size - (payload_size % self.cipher_out_block_size)
if padding_size==0:
padded = data
else:
# pad byte value is number of padding bytes added
padded = memoryview_to_bytes(data) + pad(self.cipher_out_padding, padding_size)
actual_size += padding_size
assert len(padded)==actual_size, "expected padded size to be %i, but got %i" % (len(padded), actual_size)
data = self.cipher_out.encrypt(padded)
assert len(data)==actual_size, "expected encrypted size to be %i, but got %i" % (len(data), actual_size)
cryptolog("sending %s bytes %s encrypted with %s padding", payload_size, self.cipher_out_name, padding_size)
if proto_flags & FLAGS_NOHEADER:
assert not self.cipher_out
#for plain/text packets (ie: gibberish response)
log("sending %s bytes without header", payload_size)
items.append(data)
elif actual_size<PACKET_JOIN_SIZE:
if not isinstance(data, JOIN_TYPES):
data = memoryview_to_bytes(data)
header_and_data = pack_header(proto_flags, level, index, payload_size) + data
items.append(header_and_data)
else:
header = pack_header(proto_flags, level, index, payload_size)
items.append(header)
items.append(data)
counter += 1
self.raw_write(items, start_send_cb, end_send_cb, fail_cb, synchronous, more)
def _send_async(self, packet, sync=False, fail_cb=None):
""" used by send_control to bypass the regular queuing functions,
and force enable synchronous=False
"""
#log("_send_async(%s, %s) encoder=%s, compressor=%s", packet, sync, self._encoder, self._compress)
log("_send_async(%s, %s)", packet, sync)
chunks = self.encode(packet)
if len(chunks) > 1:
return Protocol.send_now(self, packet)
proto_flags, index, level, data = chunks[0]
from xpra.net.header import pack_header
payload_size = len(data)
header_and_data = pack_header(proto_flags, level, index,
payload_size) + data
with self._write_lock:
if self._write_thread is None:
self.start_write_thread()
self._write_queue.put((header_and_data, None, None, fail_cb, sync))
