def connect(self, guest, name, secret, privacy):
host = WHubHost().acquire(guest, privacy)
if not host:
log_err(self, 'failed to acquire host, user=%s' % name)
return
real = self._get_real_name(guest)
if not self._connect(guest, real, secret, privacy, host):
WHubHost().release(host)
return
res = self._add_dev(host, Container(), real)
if not res:
self._disconnect(real, secret, privacy, host)
WHubHost().release(host)
return
res = self._add_dev(host, Monitor(), real)
if not res:
self._remove_dev(host, Container(), real)
self._disconnect(real, secret, privacy, host)
WHubHost().release(host)
return
res = self._add_dev(host, Storage(), real)
if not res:
self._remove_dev(host, Monitor(), real)
self._remove_dev(host, Container(), real)
self._disconnect(real, secret, privacy, host)
WHubHost().release(host)
return
return host
def _check_dep(buf):
if not buf:
return
dep = yaml.load(buf)
if not dep:
return
cmds = []
for i in dep:
installer = dep[i].get('installer')
if installer not in INSTALLERS:
log_err('util', 'failed to check dependency, invalid installer')
return
cmd = '%s install %s' % (installer, i)
version = dep[i].get('version')
if version:
if installer == APT:
cmd += '=%s' % version
elif installer == PIP:
cmd += '==%s' % version
cmds.append(cmd)
for cmd in cmds:
status, output = commands.getstatusoutput(cmd)
if status != 0:
log_err('util', 'failed to check dependency')
return
return True
def install_driver(uid, package, version=None):
driver_path = os.path.join(PATH_DRIVER, package)
if os.path.exists(driver_path):
shutil.rmtree(driver_path)
ret = install(uid, package, version, DRIVER)
if not ret:
log_err(
'util', 'failed to install driver, uid=%s, driver=%s, version=%s' %
(str(uid), str(package), str(version)))
return False
dirname = tempfile.mkdtemp()
try:
buf = json.loads(zlib.decompress(ret))
dep = buf['dep']
if not _check_dep(dep):
log_err(
'util',
'failed to install driver, invalid dependency, uid=%s, driver=%s, version=%s'
% (str(uid), str(package), str(version)))
return False
driver = buf['driver']
if driver:
src = os.path.join(dirname, 'driver')
os.mkdir(src)
filenames = driver.keys()
for name in filenames:
filepath = os.path.join(src, name)
with open(filepath, 'wb') as f:
f.write(driver[name])
shutil.copytree(src, driver_path)
finally:
shutil.rmtree(dirname)
return True
def __setup_fullscreen__(self):
user_choice = self.get_scummvm_fullscreenmode()
env_override = 'LUX_USE_SCREEN' in os.environ or \
'SDL_VIDEO_FULLSCREEN_DISPLAY' in os.environ or \
'SDL_VIDEO_FULLSCREEN_HEAD' in os.environ
if user_choice == 'default' and not env_override:
return
screen = self.__get_screen_number__()
all_screens = xlib.query_screens()
if all_screens == {}:
log_err('no screens detected')
for number, info in all_screens.items():
log("screen '{}': {}x{}".format(number, info.width, info.height))
if screen not in all_screens:
log("screen '{}' not found".format(screen))
if '0' in all_screens:
screen = '0'
log("using '" + screen + "' instead")
else:
log("using ScummVM default fullscreen mode")
return
log("selected screen '{}'".format(screen))
os.putenv('SDL_VIDEO_FULLSCREEN_DISPLAY', screen) # SDL >= 1.2.14
os.putenv('SDL_VIDEO_FULLSCREEN_HEAD', screen) # SDL >= 1.2.10
info = all_screens[screen]
self.fullresolution = (info.width, info.height)
def write(self, buf):
if len(self._uid) != UID_LEN:
log_err('Stream11111', 'invalid uid')
return
if self._key:
flg = FLG_SEC
else:
flg = 0
cnt = 0
length = len(buf)
total = (length + PACKET_LEN - 1) / PACKET_LEN
head = self._uid + struct.pack('I', flg) + struct.pack('I', total)
self._sock.sendall(head)
while cnt < total:
start = cnt * PACKET_LEN
end = min(start + PACKET_LEN, length)
if self._key:
body = rsa.encrypt(buf[start:end], self._key)
else:
body = buf[start:end]
head = struct.pack('H', len(body))
self._sock.sendall(head)
self._sock.sendall(body)
cnt += 1
self._sock.recv(1)
def write(self, buf):
if len(self._uid) != UID_LEN:
log_err('Stream', 'invalid uid')
return
if self._key:
flg = FLG_SEC
else:
flg = 0
cnt = 0
length = len(buf)
total = (length + PACKET_LEN - 1) / PACKET_LEN
head = self._uid + struct.pack('I', flg) + struct.pack('I', total)
self._sock.sendall(head)
while cnt < total:
start = cnt * PACKET_LEN
end = min(start + PACKET_LEN, length)
if self._key:
body = rsa.encrypt(buf[start:end], self._key)
else:
body = buf[start:end]
head = struct.pack('H', len(body))
self._sock.sendall(head)
self._sock.sendall(body)
cnt += 1
self._sock.recv(1)
def get_md5(text):
if type(text) is types.StringType:
tmp = hashlib.md5()
tmp.update(text)
return tmp.hexdigest()
else:
log_err('util', 'failed to get md5')
def run(self):
liveness = PPP_HEARTBEAT_LIVENESS
timeout = time.time() + PPP_HEARTBEAT_INTERVAL
while True:
socks = dict(self._poller.poll(PPP_HEARTBEAT_INTERVAL * 1000))
if socks.get(self._sock) == zmq.POLLIN:
frames = self._sock.recv_multipart()
if not frames:
log_err(self, 'found an empty request')
break
if len(frames) == PPP_NR_FRAMES:
res = self.proc(frames[PPP_FRAME_BUF])
msg = [frames[PPP_FRAME_ID], '', frames[PPP_FRAME_SEQ], json.dumps(res)]
self._sock.send_multipart(msg)
elif len(frames) == 1 and frames[0] == PPP_HEARTBEAT:
liveness = PPP_HEARTBEAT_LIVENESS
else:
log_err(self, "invalid request, %s" % frames)
else:
liveness -= 1
if liveness == 0:
time.sleep(random.randint(0, PPP_SLEEP_TIME))
self._reset_sock()
liveness = PPP_HEARTBEAT_LIVENESS
if time.time() > timeout:
timeout = time.time() + PPP_HEARTBEAT_INTERVAL
self._sock.send(PPP_HEARTBEAT)
def get_md5(text):
if type(text) is types.StringType:
tmp = hashlib.md5()
tmp.update(text)
return tmp.hexdigest()
else:
log_err('util', 'failed to get md5')
def _coordinate(self):
ret = -1
end = None
dest = None
req_list = []
sock = self._sock
rep_id = idx._idgen()
req = {'id':rep_id}
req_base = copy(req)
curr = WMD_REP_START
total = len(self._nodes) - 1
try:
while ret != 0:
args = self._recv(sock, timeout=WMD_REP_LONG_TIMEOUT)
if not args or not args.has_key('cmd'):
log_err(self, 'failed to coordinate')
break
cmd = args['cmd']
src = args.get('src')
off = int(cmd) - curr
if not src or src not in self._nodes or (cmd != WMD_REP_START and args.get('id') != rep_id) or off < 0 or off > 1:
self._send_req(sock, WMD_REP_EXIT)
continue
if off != 0:
cmd = WMD_REP_WAIT
self._send_req(sock, cmd, req_base)
continue
if cmd == WMD_REP_START:
target = args.get('target')
if target != self._target:
self._send_req(sock, WMD_REP_EXIT)
break
lst = args.get('lst')
if lst and (not end or idx.idxcmp(end, lst) < 0):
end = lst
dest = src
self._send_req(sock, cmd, req)
if src not in req_list:
req_list.append(src)
if len(req_list) == total:
req_list = []
if cmd == WMD_REP_START:
req.update({'dest':dest, 'end':end})
self._sync(target, self._lst, req)
curr = WMD_REP_ACCEPT
elif cmd == WMD_REP_ACCEPT:
req = copy(req_base)
curr = WMD_REP_STOP
elif cmd == WMD_REP_STOP:
ret = 0
except:
self._context.destroy()
self._init_sock(net.ntoa(self._addr))
return ret
def install(uid, package, version, typ):
addr = get_frontend()
rpcclient = RPCClient(addr, FRONTEND_PORT)
ret = rpcclient.request('install', uid=uid, package=package, version=version, typ=typ)
if not ret:
log_err('util', 'failed to install, uid=%s, package=%s, version=%s, typ=%s' % (str(uid), str(package), str(version), str(typ)))
return
return ret
def _recv(self, addr):
try:
index, cmd = self._sub[addr].recv()
self._show_recv(index)
return (index, cmd)
except:
log_err(self, 'failed to receive from %s' % net.ntoa(addr))
raise Exception(log_get(self, 'failed to receive'))
def _keep_alive(self):
try:
if self._live:
self._live(self._addr)
return True
except:
log_err(self, 'failed to keep alive')
return False
def _remove(self):
try:
if self._fault:
self._fault(self._addr)
return True
except:
log_err(self, 'failed to remove')
return False
def _count(self, index):
if not self._cnt.has_key(index):
self._cnt.update({index:0})
self._hits.update({index:0})
total = self._cnt[index]
if total >= self._total:
log_err(self, 'failed to count (out of range)')
raise Exception(log_get(self, 'out of range'))
self._cnt[index] = total + 1
def update(self, cmd):
track, orig, command = unpack(cmd)
identity = idx.idxid(orig)
addr = self._sub_addr.get(identity)
if not addr or not self._sub.has_key(addr):
log_err(self, 'failed to update (no subscriber)')
raise Exception(log_get(self, 'failed to update'))
if self._sub[addr].idxnxt(orig, command):
self._forward(orig, command)
def _recv(self, addr):
try:
if WMD_SEQ_CHK_SLOW:
self._cmd.chkslow()
return self._sub[addr].recv()
except:
log_err(self, 'failed to receive, %s' % net.ntoa(addr))
self._stop_sub(addr)
raise Exception(log_get(self, 'failed to receive'))
def get_scummvm_cmd(self):
scummvm_cmd = self.get_str('scummvm', 'cmd', DEFAULT_SCUMMVM_CMD)
cmd = os.environ.get('LUX_SCUMMVM_CMD', scummvm_cmd)
try:
split = shlex.split(cmd, comments=True)
return [os.path.expanduser(s) for s in split]
except ValueError as err:
log_err('invalid scummvm.cmd value:', err)
return [DEFAULT_SCUMMVM_CMD]
def mkactive(self, addr):
self._lock.acquire()
try:
self._que.mkactive(addr)
except:
log_err(self, 'failed to mark active node %s' % net.ntoa(addr))
raise Exception(log_get(self, 'failed to mark active node'))
finally:
self._lock.release()
def add(self, addr, index, cmd):
self._lock.acquire()
try:
return self._add_cmd(addr, index, cmd)
except:
log_err(self, 'failed to add, addr=%s' % net.ntoa(addr))
raise Exception(log_get(self, 'failed to add'))
finally:
self._lock.release()
def proc(self, op, args):
if op not in self._op:
log_err(self, 'invalid op %s' % op)
return
try:
func = getattr(self, op)
return func(*args)
except:
log_err(self, 'failed to process (op=%s)' % op)
def _proc(self, *args):
try:
req = WRouteReq()
cmd = {'task':self._task, 'args':{'op':self._op, 'args':args}, 'timeout':self._timeout}
res = req.send(cmd)
req.release()
return res
except:
log_err(self, "failed")
def _proc(self, *args):
try:
self._open()
cmd = {'ctrl':self._ctrl, 'op':self._op, 'args':args, 'timeout':self._timeout}
self._send(cmd)
return self._recv()
except:
log_err(self, 'failed')
finally:
self._close()
def _proc(self, *args):
try:
self._open()
cmd = {'viewer':self._viewer, 'op':self._op, 'args':args}
self._send(cmd)
return self._recv()
except:
log_err(self, 'failed')
finally:
self._close()
def __get_screen_number__(self):
tokens = self.get_scummvm_fullscreenmode().split()
screen = '0'
if tokens == [] or tokens[0] != 'screen':
log_err('unknown option value:', tokens[0])
if len(tokens) >= 2 and tokens[0] == 'screen':
screen = tokens[1]
screen = os.environ.get('SDL_VIDEO_FULLSCREEN_HEAD', screen)
screen = os.environ.get('SDL_VIDEO_FULLSCREEN_DISPLAY', screen)
screen = os.environ.get('LUX_USE_SCREEN', screen)
return screen
def exit(self, guest, name, secret, password, privacy, host):
if not net.validate(guest):
log_err(self, 'failed, invalid addr')
return
res = None
self._lock_acquire(guest)
if self._auth.exist(guest, name, password, privacy, host):
log(self, 'exit (%s)' % name)
res = self._conn.disconnect(guest, name, secret, privacy, host)
self._lock_release(guest)
return res
def _forward(self, index, cmd):
self._lock.acquire()
try:
new_index, new_cmd = self._cmd.wrap(self._addr, index, cmd, self._wrapper)
self._pub.send(new_cmd, new_index)
self._show_fwd(new_index)
except:
log_err(self, 'failed to forward, index=%s' % index)
raise Exception(log_get(self, 'failed to forward'))
finally:
self._lock.release()
def proc(self, sock, trig, op, args, timeout):
pool = ThreadPool(processes=1)
async = pool.apply_async(trig.proc, (op, args))
try:
res = async.get(timeout)
stream_input(sock, res)
except TimeoutError:
log_err(self, 'failed to process (timeout)')
pool.terminate()
finally:
sock.close()
def mkactive(self, addr):
if not self._stat.has_key(addr):
if len(self._active) + 1 > self._available:
log_err(self, 'failed to make active')
raise Exception(log_get(self, 'failed to make active'))
self._stat.update({addr:WMD_REC_ACTIVE})
self._active.update({addr:None})
count = self._total
for i in self._stat:
if self._stat[i] == WMD_REC_INACTIVE:
count -= 1
self._available = count
def wrap(self, addr, index, cmd, wrapper):
self._lock.acquire()
try:
track = self._que.track()
new_index, new_cmd = wrapper(track, index, cmd)
self._add_cmd(addr, new_index, new_cmd)
return (new_index, new_cmd)
except:
log_err(self, 'failed to wrap, addr=%s' % net.ntoa(addr))
raise Exception(log_get(self, 'failed to wrap'))
finally:
self._lock.release()
def readall(self):
uid = self._sock.recv(UID_LEN)
if len(uid) != UID_LEN:
log_err('Stream', 'failed to receive uid')
return (None, None, '')
buf = self._sock.recv(FLG_LEN)
if len(buf) != FLG_LEN:
log_err('Stream', 'failed to receive flag')
return (None, None, '')
flg = struct.unpack('I', buf)[0]
buf = self.read()
return (uid, flg, buf)
def _disconnect(self, name, secret, privacy, host):
try:
dev = Network()
if not dev.unregister(name, secret, privacy, host):
return
if PRIVATE == privacy or net.chkiface(NET_ADAPTER) == host:
dev.unmount(name)
else:
WHub(host, dev).unmount(name)
return True
except:
log_err(self, 'failed to disconnect')
def readall(self):
uid = self._sock.recv(UID_LEN)
if len(uid) != UID_LEN:
log_err('Stream', 'failed to receive uid')
return (None, None, '')
buf = self._sock.recv(FLG_LEN)
if len(buf) != FLG_LEN:
log_err('Stream', 'failed to receive flag')
return (None, None, '')
flg = struct.unpack('I', buf)[0]
buf = self.read()
return (uid, flg, buf)
def _pop(self):
if len(self._cand) > 0:
index = self._cand[0]
if self._is_safe(index):
cmd = self._rec.get_cmd(index)
if not cmd:
log_err(self, 'failed to get command')
raise Exception(log_get(self, 'failed to get command'))
del self._cand[0]
self._remove(index)
self._log(index)
return (index, cmd)
return (None, None)
def send(self, buf):
ret = False
if not self._connected:
log_err(self, 'no connection')
return ret
try:
self._sock.send(buf)
res = self._sock.recv()
if res and loads(res):
ret = True
except:
log_err(self, 'failed to send')
finally:
return ret
def read(self):
head = self._sock.recv(4)
if len(head) != 4:
log_err('Stream', 'failed to receive head')
return
total, = struct.unpack('I', head)
cnt = 0
res = ''
while cnt < total:
head = self._sock.recv(2)
if len(head) != 2:
log_err('Stream', 'failed to receive')
return
length, = struct.unpack('H', head)
body = ''
while len(body) < length:
buf = self._sock.recv(length - len(body))
if not buf:
log_err('Stream', 'failed to receive buf')
return
body += buf
if len(body) != length:
log_err('Stream', 'failed to receive body')
return
if self._key:
res += rsa.decrypt(body, self._key)
else:
res += body
cnt += 1
self._sock.sendall('0')
return res
def pop(self):
self._lock.acquire()
try:
index, cmd = self._que.pop()
if index and not self._event.is_set():
addr = self._que.chkslow()
if not addr or addr == self._addr:
self._event.set()
return (index, cmd)
except:
log_err(self, 'failed to pop')
raise Exception(log_get(self, 'failed to pop'))
finally:
self._lock.release()
def read(self):
head = self._sock.recv(4)
if len(head) != 4:
log_err('Stream', 'failed to receive head')
return
total, = struct.unpack('I', head)
cnt = 0
res = ''
while cnt < total:
head = self._sock.recv(2)
if len(head) != 2:
log_err('Stream', 'failed to receive')
return
length, = struct.unpack('H', head)
body = ''
while len(body) < length:
buf = self._sock.recv(length - len(body))
if not buf:
log_err('Stream', 'failed to receive buf')
return
body += buf
if len(body) != length:
log_err('Stream', 'failed to receive body')
return
if self._key:
res += rsa.decrypt(body, self._key)
else:
res += body
cnt += 1
self._sock.sendall('0')
return res
def _pop(self):
self._lock.acquire()
try:
while True:
index, cmd = self._cmd.pop()
if not index:
break
self._hdl.proc(cmd)
self._show_pop(index)
except:
log_err(self, 'failed to pop')
raise Exception(log_get(self, 'failed to pop'))
finally:
self._lock.release()
def install(uid, package, version, typ):
addr = get_frontend()
rpcclient = RPCClient(addr, FRONTEND_PORT)
if typ == DRIVER:
content = None
ret = rpcclient.request('install',
uid=uid,
package=package,
version=version,
typ=typ,
content=content)
if not ret:
log_err(
'util',
'failed to install, uid=%s, package=%s, version=%s, typ=%s' %
(str(uid), str(package), str(version), str(typ)))
return
return ret
def upload(path, uid, package, version, typ, key):
content = dump_content(path)
buf = zlib.compress(json.dumps(content))
addr = get_frontend()
rpcclient = RPCClient(addr, FRONTEND_PORT, uid, key)
ret = rpcclient.request('upload',
uid=uid,
package=package,
version=version,
buf=buf,
typ=typ)
if ret:
return True
else:
log_err(
'util',
'failed to upload, uid=%s, package=%s, version=%s, typ=%s' %
(str(uid), str(package), str(version), str(typ)))
return False
