/usr/lib/python2.7/dist-packages/xpra/net/packet_encoding.py is in xpra 0.17.6+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | #!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2011-2014 Antoine Martin <antoine@devloop.org.uk>
# Copyright (C) 2008, 2009, 2010 Nathaniel Smith <njs@pobox.com>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os
from xpra.log import Logger
log = Logger("network", "protocol")
from xpra.net.header import FLAGS_RENCODE, FLAGS_YAML, FLAGS_BENCODE
#those are also modified from the command line switch:
use_rencode = os.environ.get("XPRA_USE_RENCODER", "1")=="1"
use_bencode = os.environ.get("XPRA_USE_BENCODER", "1")=="1"
use_yaml = os.environ.get("XPRA_USE_YAML", "1")=="1"
has_rencode = None
rencode_dumps, rencode_loads, rencode_version = None, None, None
def init_rencode():
global use_rencode, has_rencode, rencode_dumps, rencode_loads, rencode_version
try:
import rencode
rencode_dumps = rencode.dumps
rencode_loads = rencode.loads
try:
rencode_version = rencode.__version__
log("loaded rencode version %s from %s", rencode_version, rencode.__file__)
except:
log.warn("rencode at '%s' lacks versioning information", rencode.__file__)
rencode_version = "unknown"
except ImportError as e:
log("init_rencode()", exc_info=True)
if use_rencode:
log.warn("Warning: rencode import failed:")
log.warn(" %s", e)
except Exception as e:
log.error("error loading rencode", exc_info=True)
has_rencode = rencode_dumps is not None and rencode_loads is not None and rencode_version is not None
use_rencode = has_rencode and use_rencode
log("packet_encoding.init_rencode() has_rencode=%s, use_rencode=%s, version=%s", has_rencode, use_rencode, rencode_version)
has_bencode = None
bencode, bdecode, bencode_version = None, None, None
def init_bencode():
global use_bencode, has_bencode, bencode, bdecode, bencode_version
try:
from xpra.net.bencode import bencode, bdecode, __version__ as bencode_version
except ImportError as e:
log("init_bencode()", exc_info=True)
if use_bencode:
log.warn("Warning: bencode import failed:")
log.warn(" %s", e)
except Exception as e:
log.error("error loading bencoder", exc_info=True)
has_bencode = bencode is not None and bdecode is not None
use_bencode = has_bencode and use_bencode
log("packet_encoding.init_bencode() has_bencode=%s, use_bencode=%s, version=%s", has_bencode, use_bencode, bencode_version)
has_yaml = None
yaml_encode, yaml_decode, yaml_version = None, None, None
def init_yaml():
global use_yaml, has_yaml, yaml_encode, yaml_decode, yaml_version
try:
#json messes with strings and unicode (makes it unusable for us)
import yaml
yaml_encode = yaml.dump
yaml_decode = yaml.load
yaml_version = yaml.__version__
except ImportError:
log("yaml not found")
has_yaml = yaml_encode is not None and yaml_decode is not None
use_yaml = has_yaml and use_yaml
log("packet encoding: has_yaml=%s, use_yaml=%s, version=%s", has_yaml, use_yaml, yaml_version)
def init():
init_rencode()
init_bencode()
init_yaml()
init()
def do_bencode(data):
return bencode(data), FLAGS_BENCODE
def do_rencode(data):
return rencode_dumps(data), FLAGS_RENCODE
def do_yaml(data):
return yaml_encode(data), FLAGS_YAML
def get_packet_encoding_caps():
r = {"" : use_rencode}
if has_rencode:
assert rencode_version is not None
r["version"] = rencode_version
b = {"" : use_bencode}
if has_bencode:
assert bencode_version is not None
b["version"] = bencode_version
y = {"" : use_yaml}
if has_yaml:
assert yaml_version is not None
y["version"] = yaml_version
return {
"rencode" : r,
"bencode" : b,
"yaml" : y,
}
#all the encoders we know about, in best compatibility order:
ALL_ENCODERS = ["bencode", "rencode", "yaml"]
#order for performance:
PERFORMANCE_ORDER = ["rencode", "bencode", "yaml"]
_ENCODERS = {
"rencode" : do_rencode,
"bencode" : do_bencode,
"yaml" : do_yaml,
}
def get_enabled_encoders(order=ALL_ENCODERS):
enabled = [x for x,b in {
"rencode" : use_rencode,
"bencode" : use_bencode,
"yaml" : use_yaml,
}.items() if b]
log("get_enabled_encoders(%s) enabled=%s", order, enabled)
#order them:
return [x for x in order if x in enabled]
def get_encoder(e):
assert e in ALL_ENCODERS, "invalid encoder name: %s" % e
assert e in get_enabled_encoders(), "%s is not available" % e
return _ENCODERS[e]
def get_encoder_name(e):
assert e in _ENCODERS.values(), "invalid encoder: %s" % e
for k,v in _ENCODERS.items():
if v==e:
return k
raise Exception("impossible bug!")
def get_packet_encoding_type(protocol_flags):
if protocol_flags & FLAGS_RENCODE:
return "rencode"
elif protocol_flags & FLAGS_YAML:
return "yaml"
else:
return "bencode"
def sanity_checks():
if not use_rencode:
log.warn("Warning: 'rencode' packet encoder not found")
log.warn(" the other packet encoders are much slower")
class InvalidPacketEncodingException(Exception):
pass
def decode(data, protocol_flags):
if protocol_flags & FLAGS_RENCODE:
if not has_rencode:
raise InvalidPacketEncodingException("rencode is not available")
if not use_rencode:
raise InvalidPacketEncodingException("rencode is disabled")
return list(rencode_loads(data))
elif protocol_flags & FLAGS_YAML:
if not has_yaml:
raise InvalidPacketEncodingException("yaml is not available")
if not use_yaml:
raise InvalidPacketEncodingException("yaml is disabled")
return list(yaml_decode(data))
else:
if not has_bencode:
raise InvalidPacketEncodingException("bencode is not available")
if not use_bencode:
raise InvalidPacketEncodingException("bencode is disabled")
packet, l = bdecode(data)
assert l==len(data)
return packet
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Packet Encoding", "Packet Encoding Info"):
print_nested_dict(get_packet_encoding_caps())
if __name__ == "__main__":
main()
|